Workaround:
private void PrintPivotGrid()
{
    MyPivotGridPrintStyle style = new MyPivotGridPrintStyle();
    style.LayoutType = PivotLayout.Tabular;
    this.radPivotGrid1.PrintStyle = style;
    this.radPivotGrid1.PrintPreview();
}

public class MyPivotGridPrintStyle : PivotGridPrintStyle
{
    public override void Initialize()
    {
        base.Initialize();

        FieldInfo fiColumnWidths = this.GetType().BaseType.GetField("columnWidths", BindingFlags.Instance | BindingFlags.NonPublic);
        List<int> columnWidths = (List<int>)fiColumnWidths.GetValue(this);
        RadPivotGridElement pivotGrid = (RadPivotGridElement)this.GetType().BaseType.GetField("pivotGrid", BindingFlags.Instance | BindingFlags.NonPublic)
                                                                                    .GetValue(this);

        for (int i = 0; i < pivotGrid.RowDescriptorsArea.Children.Count; i++)
        {
            RadElement descriptor = pivotGrid.RowDescriptorsArea.Children[i];
            columnWidths[i] = descriptor.Size.Width;
        }
    }
}

Until the feature gets implemented use custom PivotGridPrintStyle:

Public Class MyPivotGridPrintStyle
    Inherits PivotGridPrintStyle

    Const MIN_SPACE As Integer = 1

    Public Overrides Sub DrawPage(drawArea As Rectangle, graphics As Graphics, pageNumber As Integer)

        If Me.PivotGrid.ColumnHeaderHeight > MIN_SPACE Then
            MyBase.DrawPage(drawArea, graphics, pageNumber)

        Else
            Dim x As Integer = drawArea.X
            Dim y As Integer = drawArea.Y
            Dim scale As SizeF = DirectCast(Me.GetType().BaseType.GetMethod("GetScaleFactors", BindingFlags.Instance Or BindingFlags.NonPublic).Invoke(Me, New Object() {drawArea}), SizeF)

            Dim startColumn As Integer = DirectCast(Me.GetType().BaseType.GetMethod("GetStartColumn", BindingFlags.Instance Or BindingFlags.NonPublic).Invoke(Me, New Object() {pageNumber, drawArea, scale.Width}), Integer)
            Dim endColumn As Integer = DirectCast(Me.GetType().BaseType.GetMethod("GetEndColumn", BindingFlags.Instance Or BindingFlags.NonPublic).Invoke(Me, New Object() {startColumn, drawArea, scale.Width}), Integer)
            Dim startRow As Integer = DirectCast(Me.GetType().BaseType.GetMethod("GetStartRow", BindingFlags.Instance Or BindingFlags.NonPublic).Invoke(Me, New Object() {pageNumber, drawArea, scale.Height}), Integer)
            Dim endRow As Integer = DirectCast(Me.GetType().BaseType.GetMethod("GetEndRow", BindingFlags.Instance Or BindingFlags.NonPublic).Invoke(Me, New Object() {startRow, drawArea, scale.Height}), Integer)

            If Me.PivotGrid.ColumnHeaderHeight <= MIN_SPACE Then
                startRow += 1
            End If

            For i As Integer = startRow To endRow
                x = drawArea.X
                Dim maxHeight As Integer = 0

                For j As Integer = startColumn To endColumn
                    Dim columnWidths = DirectCast(Me.GetType().BaseType.GetField("columnWidths", BindingFlags.Instance Or BindingFlags.NonPublic).GetValue(Me), List(Of Integer))
                    Dim rowHeights = DirectCast(Me.GetType().BaseType.GetField("rowHeights", BindingFlags.Instance Or BindingFlags.NonPublic).GetValue(Me), List(Of Integer))

                    Dim elementRect As New Rectangle(x, y, columnWidths(j), rowHeights(i))
                    Dim printElement As RadPrintElement = Me.GetPrintElementForCell(i, j)
                    printElement.ScaleTransform = scale
                    Dim transformedRect As RectangleF = printElement.GetTransformedBounds(elementRect)

                    Me.PrintElement(printElement, drawArea, elementRect, graphics)
                    x += CInt(Math.Floor(transformedRect.Width))
                    maxHeight = Math.Max(maxHeight, CInt(Math.Floor(transformedRect.Height)))
                Next

                y += maxHeight
            Next
        End If
    End Sub

End Class

How to reproduce check the attached project and video

Workaround: handle the UpdateCompleted event and explicitly set the properties to true

public LocalDataSourceSerializerForm()
{
    InitializeComponent();

    this.radPivotGrid1.AutoExpandColumnHeaders = false;
    this.radPivotGrid1.AutoExpandRowHeaders = false;

    this.radPivotGrid1.UpdateCompleted += radPivotGrid1_UpdateCompleted;
}

private void radPivotGrid1_UpdateCompleted(object sender, EventArgs e)
{
    this.radPivotGrid1.AutoExpandColumnHeaders = true;
    this.radPivotGrid1.AutoExpandRowHeaders = true;
}

Workaround: 
public class MyRadPivotGrid : RadPivotGrid
{
    public override void SaveLayout(string fileName)
    {
        ComponentXmlSerializer ser = new ComponentXmlSerializer(this.XmlSerializationInfo);

        using (XmlTextWriter writer = new XmlTextWriter(fileName, Encoding.UTF8))
        {
            writer.Formatting = Formatting.Indented;
            writer.WriteStartElement("RadPivotGrid");
            ser.WriteObjectElement(writer, this);
        }
    }
}

How to reproduce:

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    private void Form1_MouseDoubleClick(object sender, MouseEventArgs e)
    {
        PivotGridSpreadExport spreadExport = new PivotGridSpreadExport(this.radPivotGrid1);

        spreadExport.RunExport(@"..\..\exported-file.xlsx", new SpreadExportRenderer());
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        this.productsTableAdapter.Fill(this.nwindDataSet.Products);

        LocalDataSourceProvider dataProvider = new LocalDataSourceProvider();

        dataProvider.ItemsSource = nwindDataSet.Products;

        dataProvider.BeginInit();
        dataProvider.RowGroupDescriptions.Add(new PropertyGroupDescription() { PropertyName = "CategoryID", GroupComparer = new GroupNameComparer() });
        dataProvider.AggregateDescriptions.Add(new PropertyAggregateDescription() { PropertyName = "UnitPrice", AggregateFunction = AggregateFunctions.Sum });
        dataProvider.EndInit();

        this.radPivotGrid1.DataProvider = dataProvider;
    }
}


Workaround: create a custom pivot grid export object

 public partial class Form1 : Form
 {
     public Form1()
     {
         InitializeComponent();
     }

     private void Form1_MouseDoubleClick(object sender, MouseEventArgs e)
     {
         MyPivotGridSpreadExport spreadExport = new MyPivotGridSpreadExport(this.radPivotGrid1);

         spreadExport.RunExport(@"..\..\exported-file.xlsx", new SpreadExportRenderer());
     }

     private void Form1_Load(object sender, EventArgs e)
     {
         this.productsTableAdapter.Fill(this.nwindDataSet.Products);

         LocalDataSourceProvider dataProvider = new LocalDataSourceProvider();

         dataProvider.ItemsSource = nwindDataSet.Products;

         dataProvider.BeginInit();
         dataProvider.RowGroupDescriptions.Add(new PropertyGroupDescription() { PropertyName = "CategoryID", GroupComparer = new GroupNameComparer() });
         dataProvider.AggregateDescriptions.Add(new PropertyAggregateDescription() { PropertyName = "UnitPrice", AggregateFunction = AggregateFunctions.Sum });
         dataProvider.EndInit();

         this.radPivotGrid1.DataProvider = dataProvider;
     }
 }

public class MyPivotGridSpreadExport : PivotGridSpreadExport
{
    public MyPivotGridSpreadExport(RadPivotGrid pivotGrid)
        : base(pivotGrid) { }

    public override void Initialize()
    {
        base.Initialize();

        RadPivotGridElement pivotGrid = this.GetType().BaseType.GetField("pivotGrid", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(this) as RadPivotGridElement;
        List<int> rowHeights = this.GetType().BaseType.GetField("rowHeights", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(this) as List<int>;
        List<DescriptionBase> columnDescriptions = this.GetType().BaseType.GetField("columnDescriptions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(this) as List<DescriptionBase>;

        if (columnDescriptions.Count == 0)
        {
            rowHeights.Add(pivotGrid.RowHeight);
            columnDescriptions.Add(null);
        }
    }
}

Workaround: create a custom Top10FilterOptionsDialog

public Form1()
{
    InitializeComponent();

    this.radPivotFieldList1.DialogsFactory = new MyDialogsFactory();
}

public class MyDialogsFactory : PivotGridDialogsFactory
{
    public override ITop10FilterOptionsDialog CreateTop10FilterOptionsDialog()
    {
        return new MyTop10FilterOptionsDialog();
    }
}

public class MyTop10FilterOptionsDialog : Top10FilterOptionsDialog
{
    public override void LoadSettings(Telerik.Pivot.Core.Filtering.ITopGroupsFilter filter, string fieldName, IEnumerable<string> aggregateNames)
    {
        base.LoadSettings(filter, fieldName, aggregateNames);

        if (filter != null)
        {
            ((RadDropDownList)this.Controls["groupBox"].Controls["dropDownTopBottom"]).SelectedValue = filter.Selection;
        }
    }
}

Workaround: use custom context menu

 public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();

            MyPivotGridContextMenu menu = new MyPivotGridContextMenu(this.radPivotGrid1.PivotGridElement);
            this.radPivotGrid1.PivotGridElement.ContextMenu = menu;
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            this.productsTableAdapter.Fill(this.nwindDataSet.Products);

            LocalDataSourceProvider dataProvider = new LocalDataSourceProvider();

            dataProvider.ItemsSource = nwindDataSet.Products;

            dataProvider.BeginInit();
            dataProvider.RowGroupDescriptions.Add(new PropertyGroupDescription() { PropertyName = "CategoryID", GroupComparer = new GroupNameComparer() });
            dataProvider.RowGroupDescriptions.Add(new PropertyGroupDescription() { PropertyName = "ProductName", GroupComparer = new GroupNameComparer() });
            dataProvider.ColumnGroupDescriptions.Add(new PropertyGroupDescription() { PropertyName = "ProductID" });
            dataProvider.AggregateDescriptions.Add(new PropertyAggregateDescription() { PropertyName = "UnitPrice", AggregateFunction = AggregateFunctions.Sum });
            dataProvider.EndInit();

            this.radPivotGrid1.DataProvider = dataProvider;
        }
    }

public class MyPivotGridContextMenu : PivotGridContextMenu
{
    public MyPivotGridContextMenu(RadPivotGridElement pivotGridElement)
        : base(pivotGridElement)
    { }


    protected override void OnCollapseAllMenuItemClick(object sender, EventArgs e)
    {
        PivotGroupElement groupElement = this.Context as PivotGroupElement;

        if (groupElement != null)
        {
             RadPivotGridElement pivotGridElement = this.GetType().BaseType
                .GetField("pivotGridElement", BindingFlags.Instance | BindingFlags.NonPublic)
                .GetValue(this) as RadPivotGridElement;

            pivotGridElement.SuspendLayout(true);

            if (groupElement.Data.Axis == PivotAxis.Rows)
            {
                foreach (PivotGroupNode node in pivotGridElement.GetRowGroups())
                {
                    node.Expanded = false;
                }
            }
            else
            {
                foreach (PivotGroupNode node in pivotGridElement.GetColumnGroups())
                {
                    node.Expanded = false;
                }
            }

            pivotGridElement.ResumeLayout(true, true);
            pivotGridElement.UpdateAfterExpandCollapse();
        }
    }
}

Workaround:

private IList<PivotGroupNode> collapsedRowsNodes;
private void customMenuItem_Click(object sender, EventArgs e)
{
    PivotGridSpreadExport spreadExport = new PivotGridSpreadExport(pivotGrid);
    spreadExport.ExportCompleted += spreadExport_ExportCompleted;
    spreadExport.ExportFlatData = true;

    this.collapsedRowsNodes = new List<PivotGroupNode>();
    PivotGridGroupTraverser rowTraverser = (PivotGridGroupTraverser)this.pivotGrid.PivotGridElement.RowScroller.Traverser.GetEnumerator();
    while (rowTraverser.MoveNext())
    {
        PivotGroupNode current = rowTraverser.Current;
        if (!current.Expanded)
        {
            this.collapsedRowsNodes.Add(current);
            current.Expanded = true;
        }
    }

    spreadExport.RunExport(@"..\..\export.xlsx", new SpreadExportRenderer());
}

private void spreadExport_ExportCompleted(object sender, EventArgs e)
{
    foreach (PivotGroupNode node in this.collapsedRowsNodes)
    {
        node.Expanded = false;
    }
}

To reproduce:

this.ordersTableAdapter.Fill(this.nwindDataSet.Orders);
this.radPivotGrid1.RowGroupDescriptions.Add(new DateTimeGroupDescription() 
{ PropertyName = "OrderDate", Step = DateTimeStep.Year, GroupComparer = new GroupNameComparer() });
this.radPivotGrid1.RowGroupDescriptions.Add(new DateTimeGroupDescription() 
{ PropertyName = "OrderDate", Step = DateTimeStep.Quarter, GroupComparer = new GroupNameComparer() });
this.radPivotGrid1.RowGroupDescriptions.Add(new DateTimeGroupDescription() 
{ PropertyName = "OrderDate", Step = DateTimeStep.Month, GroupComparer = new GroupNameComparer() });
this.radPivotGrid1.ColumnGroupDescriptions.Add(new PropertyGroupDescription() 
{ PropertyName = "EmployeeID", GroupComparer = new GrandTotalComparer() });
this.radPivotGrid1.FilterDescriptions.Add(new PropertyFilterDescription() 
{ PropertyName = "ShipCountry", CustomName = "Country" });
this.radPivotGrid1.DataSource = this.ordersBindingSource;


Workaround:

public Form1()
{
    InitializeComponent();

    this.radPivotGrid1.DialogsFactory = new MyDialogsFactory();
    this.radPivotFieldList1.DialogsFactory = new MyDialogsFactory();
}

public class MyDialogsFactory : PivotGridDialogsFactory
{
    public override ITop10FilterOptionsDialog CreateTop10FilterOptionsDialog()
    {
        return new MyITop10FilterOptionsDialog();
    } 
}

public class MyITop10FilterOptionsDialog : Top10FilterOptionsDialog 
{
    public override ITopGroupsFilter SelectedFilter
    {
        get
        {
            if (((RadDropDownList)this.Controls["groupBox"].Controls["dropDownFields"]).SelectedValue == null)
            {
                return null;
            }
            return base.SelectedFilter;
        }
    }
}

Steps to reproduce:
Just add a value filter using the ValueFilterDialog. The filter is being applied properly, however, if you read the PropertyGroupDescription to which the filter has been added and check its AggregateIndex property, it is always 0.

Workaround: Use a custom ValueFilterDialog: http://docs.telerik.com/devtools/winforms/pivotgrid/dialogs/customizing-the-dialogs

this.radPivotGrid1.DialogsFactory = new MyDialogsFactory();
this.radPivotFieldList1.DialogsFactory = new MyDialogsFactory();

public class MyDialogsFactory : PivotGridDialogsFactory
{
    public override IValueFilterOptionsDialog CreateValueFilterOptionsDialog()
    {
        return new MyValueFilterOptionsDialog();
    }
}

public partial class MyValueFilterOptionsDialog : ValueFilterOptionsDialog
{
    public override Telerik.Pivot.Core.Filtering.IValueGroupFilter SelectedFilter
    {
        get
        {
            IValueGroupFilter filter =  base.SelectedFilter;
            filter.AggregateIndex = ((RadDropDownList)this.Controls["groupBox"].Controls["dropDownField"]).SelectedIndex;

            return filter;
        }

public override void LoadSettings(IValueGroupFilter filter, IValueGroupFilterHost filterHost, string fieldName, IEnumerable<string> aggregateNames)
{
    base.LoadSettings(filter, filterHost, fieldName, aggregateNames);
    if (filter != null)
    {
        ((RadDropDownList)this.Controls["groupBox"].Controls["dropDownField"]).SelectedIndex = filter.AggregateIndex;
    }
}

    }
}

To reproduce: 
1. Add RadPivotGrid on the form and populate it with data 
2. Add 2 buttons to export to xls and xlsx formats 
3. Run the form and export to xls format 
4. Minimize the form. You will see that one of row is disappeared
5. Repeat the same action and you will see that a second row is disappeared. 

The issue if observed with both exporter providers (PivotGridSpreadExport/PivotExportToExcelML) and export with visual settings. 

Workaround: 
In the handler of the SizeChanged event clear the cached elements: 
void Form1_SizeChanged(object sender, EventArgs e)
{
    this.radPivotGrid1.PivotGridElement.PivotRowsContainer.ElementProvider.ClearCache(); 
}

Workaround: 

Use the new PivotGridSpreadExport class: http://www.telerik.com/help/winforms/pivotgrid-export-srpead-export.html

To reproduce:
Set the decimal separator to comma(,) in your regional settings and export the RadPivotGrid using PivotExportToExcellML. Open the exported file and you will see that the font size is very big.
Workaround:
Subscribe to the PivotExcelCellFormatting event and set the font size to an integer value:
void excelExporter_PivotExcelCellFormatting(object sender, ExcelPivotCellExportingEventArgs e)
{
    e.Cell.Font = new Font(e.Cell.Font.Name, (int)e.Cell.Font.Size, e.Cell.Font.Style);
}

To reproduce:
Resize some of the columns in PivotGrid and then export it with PivotExporttoExcelML. All columns in exported file have the same width.
Workaround:
Use PivotGridSpreadExport.

To reproduce:
In RadPivotGrid set some cell values to start with "=" or "-". Export it using PivotGridSpreadExport. The exporter tries to convert the value to formula and if this is not successful an exception is thrown.

Workaround:
private void radButtonNewPivotToExcel_Click(object sender, EventArgs e)
{
    SaveFileDialog saveFileDialog = new SaveFileDialog();
    saveFileDialog.Filter = "Excel files (*.xlsx)|*.xlsx";
    if (saveFileDialog.ShowDialog() == DialogResult.OK)
    {
        SpreadExportRenderer renderer = new SpreadExportRenderer();
        MyPivotSpreadExport exporter = new MyPivotSpreadExport(this.radPivotGrid1, renderer);
        exporter.ExportFormat = SpreadExportFormat.Xlsx;
        exporter.RunExportAsync(saveFileDialog.FileName + ".xlsx", renderer);
    }
}

public class MyPivotSpreadExport : PivotGridSpreadExport
{
    private ISpreadExportRenderer spreadExportRenderer;

    public MyPivotSpreadExport(RadPivotGrid pivotGrid, ISpreadExportRenderer renderer)
        : base(pivotGrid)
    {
        this.spreadExportRenderer = renderer;
    }

    protected override void AddRowToWorksheet(PivotGridExportRowElement rowElement)
    {
        foreach (PivotGridSpreadExportCellElement exportCell in rowElement.Cells)
        {
            this.spreadExportRenderer.CreateCellSelection(rowElement.Index, exportCell.ColumnIndex);

            Color borderColor = this.ShowGridLines ? exportCell.BorderColor : Color.Transparent;
            this.spreadExportRenderer.CreateCellStyleInfo(exportCell.BackColor, exportCell.ForeColor, exportCell.Font.FontFamily, exportCell.Font.Size,
                exportCell.Font.Bold, exportCell.Font.Italic, exportCell.Font.Underline, exportCell.TextAlignment, exportCell.TextWrap, BorderBoxStyle.SingleBorder,
                borderColor, Color.Empty, Color.Empty, Color.Empty, Color.Empty);

            if (exportCell.DataType == DataType.String || exportCell.DataType == DataType.Other)
            {
                this.spreadExportRenderer.SetCellSelectionFormat("@");
            }
            this.spreadExportRenderer.SetCellSelectionValue(exportCell.DataType, exportCell.Value ?? exportCell.Text);
        }
    }
}

Wokaround:

Private Sub GroupDescriptorElementCreating(sender As Object, e As Telerik.WinControls.UI.GroupDescriptorElementCreatingEventArgs)
    RemoveHandler e.GroupDescriptorElement.FilterPopup.TextBoxMenuItem.TextBox.TextChanged, AddressOf TextBoxMenuItemTextChanged
    AddHandler e.GroupDescriptorElement.FilterPopup.TextBoxMenuItem.TextBox.TextChanged, AddressOf TextBoxMenuItemTextChanged 
End Sub

Private Sub TextBoxMenuItemTextChanged(sender As Object, e As EventArgs)
    Dim tb As RadTextBox = TryCast(sender, RadTextBox)
    Dim popup As PivotGroupFilterPopup = TryCast(tb.Parent, PivotGroupFilterPopup)
    popup.TreeViewMenuItem.TreeElement.TreeView.EndUpdate()
End Sub

Workaround:
public Form1()
{
    InitializeComponent();
    this.radPivotGrid1.GroupDescriptorElementCreating += radPivotGrid1_GroupDescriptorElementCreating;
}

private void radPivotGrid1_GroupDescriptorElementCreating(object sender, Telerik.WinControls.UI.GroupDescriptorElementCreatingEventArgs e)
{
    e.GroupDescriptorElement.FilterPopup.PopupOpened -= FilterPopup_PopupOpened;
    e.GroupDescriptorElement.FilterPopup.PopupOpened += FilterPopup_PopupOpened;
}

private void FilterPopup_PopupOpened(object sender, EventArgs args)
{
    PivotGroupFilterPopup filterPopup = (PivotGroupFilterPopup)sender;
    RadTreeView tree = filterPopup.TreeViewMenuItem.TreeElement.TreeView;

    ((RadScrollBarElement)tree.TreeViewElement.Children[2]).Value = 10;
    ((RadScrollBarElement)tree.TreeViewElement.Children[2]).Value = 0;
}

Workaround: 

private void radPivotGrid1_GroupDescriptorElementCreating(object sender, Telerik.WinControls.UI.GroupDescriptorElementCreatingEventArgs e)
{
    e.GroupDescriptorElement.FilterPopup.PopupOpened -= FilterPopup_PopupOpened;
    e.GroupDescriptorElement.FilterPopup.PopupOpened += FilterPopup_PopupOpened;
}

private void FilterPopup_PopupOpened(object sender, EventArgs args)
{
    PivotGroupFilterPopup filterPopup = (PivotGroupFilterPopup)sender;
    RadTreeView tree = filterPopup.TreeViewMenuItem.TreeElement.TreeView;
    int height = this.CalculateHeight(tree);
    if (height > tree.Height)
    {
        ((RadScrollBarElement)tree.TreeViewElement.Children[2]).Value = 0;
        ((RadScrollBarElement)tree.TreeViewElement.Children[2]).Maximum = height;
        ((RadScrollBarElement)tree.TreeViewElement.Children[2]).Visibility = Telerik.WinControls.ElementVisibility.Visible;
    }
}

private int CalculateHeight(RadTreeView tree)
{
    int height = 0;
    for (int i = 0; i < tree.Nodes[0].Nodes.Count + 1; i++)
    {
        height += tree.ItemHeight;
    }

    return height;
}

Workaround: 
PivotExportToExcelML.ExportVisualSettings = false;