diff --git a/MetaMorpheus/GUI/MetaDraw/MetaDraw.xaml.cs b/MetaMorpheus/GUI/MetaDraw/MetaDraw.xaml.cs
index c23820447..4a524c6d3 100644
--- a/MetaMorpheus/GUI/MetaDraw/MetaDraw.xaml.cs
+++ b/MetaMorpheus/GUI/MetaDraw/MetaDraw.xaml.cs
@@ -191,14 +191,16 @@ private void dataGridScanNums_SelectedCellsChanged(object sender, SelectedCellsC
             // Chimera plotter
             if (MetaDrawTabControl.SelectedContent is Grid { Name: "chimeraPlotGrid" })
             {
+                ClearPresentationArea();
+                chimeraPlot.Visibility = Visibility.Visible;
                 List<PsmFromTsv> chimericPsms = MetaDrawLogic.FilteredListOfPsms
                     .Where(p => p.Ms2ScanNumber == psm.Ms2ScanNumber && p.FileNameWithoutExtension == psm.FileNameWithoutExtension).ToList();
                 MetaDrawLogic.DisplayChimeraSpectra(chimeraPlot, chimericPsms, out List<string> error);
                 if (error != null && error.Count > 0)
                     Debugger.Break();
-                ClearPresentationArea();
                 wholeSequenceCoverageHorizontalScroll.Visibility = Visibility.Collapsed;
-
+                AmbiguousWarningTextBlocks.Visibility = Visibility.Collapsed;
+                AmbiguousSequenceOptionBox.Visibility = Visibility.Collapsed;
 
                 if (MetaDrawSettings.ShowLegend)
                 {
@@ -217,7 +219,27 @@ private void dataGridScanNums_SelectedCellsChanged(object sender, SelectedCellsC
             // Clicking the research button on an ambiguous psm => research with new ions
             if (psm.FullSequence.Contains('|') && (sender.ToString() == "System.Object" || sender is FragmentationReanalysisViewModel))
             {
-                psm = (PsmFromTsv)AmbiguousSequenceOptionBox.SelectedItem;
+                // From chimeric scan view to child scan view with ambiguous selected
+                if (AmbiguousSequenceOptionBox.SelectedItem == null) 
+                {
+                    // set to first and break the loop if casted successfully
+                    foreach (var ambiguousResult in AmbiguousSequenceOptionBox.Items)
+                    {
+                        psm = ambiguousResult as PsmFromTsv;
+                        if (psm != null)
+                            break;
+                    }
+
+                    AmbiguousWarningTextBlocks.Visibility = Visibility.Collapsed;
+                    AmbiguousSequenceOptionBox.Visibility = Visibility.Visible;
+                    AmbiguousSequenceOptionBox.SelectedItem = psm;
+                }
+                // selecting a different ambiguous result from the combobox in child scan view
+                else
+                {
+                    psm = (PsmFromTsv)AmbiguousSequenceOptionBox.SelectedItem;
+                }
+
                 if (FragmentationReanalysisViewModel.Persist || sender is FragmentationReanalysisViewModel)
                 {
                     oldMatchedIons = psm.MatchedIons;
@@ -918,8 +940,15 @@ private void AmbiguousSequenceOptionBox_SelectionChanged(object sender, Selectio
             SetSequenceDrawingPositionSettings(true);
             object obj = new object();
             if (AmbiguousSequenceOptionBox.Items.Count > 0)
+            {
                 dataGridScanNums_SelectedCellsChanged(obj, null);
-            MetaDrawLogic.DisplaySequences(stationarySequenceCanvas, scrollableSequenceCanvas, sequenceAnnotationCanvas, psm);
+                MetaDrawLogic.DisplaySequences(stationarySequenceCanvas, scrollableSequenceCanvas,
+                    sequenceAnnotationCanvas, psm);
+            }
+            else
+            {
+                AmbiguousSequenceOptionBox.Visibility = Visibility.Hidden;
+            }
         }
 
         /// <summary>
@@ -1033,6 +1062,7 @@ private void MetaDrawTabControl_OnSelectionChanged(object sender, SelectionChang
             if (e.RemovedItems.Count > 0 && ((TabItem)e.RemovedItems[0]).Name == "ChimeraScanPlot")
             {
                 MetaDrawLogic.FilterPsms();
+                ClearPresentationArea();
 
                 // reselect what was selected
                 if (selectedPsm != null && MetaDrawLogic.FilteredListOfPsms.Contains(selectedPsm))
@@ -1047,12 +1077,15 @@ private void MetaDrawTabControl_OnSelectionChanged(object sender, SelectionChang
             if (e.AddedItems.Count > 0 && ((TabItem)e.AddedItems[0]).Name == "ChimeraScanPlot")
             {
                 MetaDrawLogic.FilterPsmsToChimerasOnly();
+                ClearPresentationArea();
 
-                // reselect what was selected
-                if (selectedPsm == null || !MetaDrawLogic.FilteredListOfPsms.Contains(selectedPsm)) return;
-                int psmIndex = MetaDrawLogic.FilteredListOfPsms.IndexOf(selectedPsm);
-                dataGridScanNums.SelectedIndex = psmIndex;
-                dataGridScanNums_SelectedCellsChanged(new object(), null);
+                // reselect what was selected if possible
+                if (selectedPsm != null && MetaDrawLogic.FilteredListOfPsms.Contains(selectedPsm))
+                {
+                    int psmIndex = MetaDrawLogic.FilteredListOfPsms.IndexOf(selectedPsm);
+                    dataGridScanNums.SelectedIndex = psmIndex;
+                    dataGridScanNums_SelectedCellsChanged(new object(), null);
+                }
             }
         }
 
@@ -1066,11 +1099,11 @@ private void ClearPresentationArea()
             DrawnSequence.ClearCanvas(map);
             DrawnSequence.ClearCanvas(sequenceText);
             DrawnSequence.ClearCanvas(sequenceAnnotationCanvas);
-            plotView.Visibility = Visibility.Hidden;
             GrayBox.Opacity = 0;
             wholeSequenceCoverageHorizontalScroll.Visibility = Visibility.Collapsed;
             AmbiguousSequenceOptionBox.Items.Clear();
             plotView.Visibility = Visibility.Hidden;
+            chimeraPlot.Visibility = Visibility.Hidden;
 
             if (ChimeraLegend != null)
                 ChimeraLegend.Visibility = false;
diff --git a/MetaMorpheus/GUI/Views/FragmentReanalysisControl.xaml b/MetaMorpheus/GUI/Views/FragmentReanalysisControl.xaml
index 71de1ed97..e0e555126 100644
--- a/MetaMorpheus/GUI/Views/FragmentReanalysisControl.xaml
+++ b/MetaMorpheus/GUI/Views/FragmentReanalysisControl.xaml
@@ -18,34 +18,46 @@
 
         <!-- All options in the header -->
         <Grid Grid.Row="0">
-            <Grid.RowDefinitions>
-                <RowDefinition Height="*"/>
-            </Grid.RowDefinitions>
             <Grid.ColumnDefinitions>
                 <ColumnDefinition Width="Auto"/>
-                <ColumnDefinition Width="*"/>
-                <ColumnDefinition Width="*"/>
-                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="2*"/>
+                <ColumnDefinition Width="3*"/>
+                <ColumnDefinition Width="3*"/>
+                <ColumnDefinition Width="3*"/>
             </Grid.ColumnDefinitions>
 
-            <Button Grid.Row="0" Grid.Column="0" x:Name="SearchButton"  Grid.RowSpan="2" Content="Search"  VerticalAlignment="Center" Margin="5 3" 
-            VerticalContentAlignment="Center" Click="SearchWithNewIons_OnClick"/>
-            <CheckBox Grid.Row="0" Grid.Column="1" Grid.RowSpan="2" Content="Persist?" VerticalAlignment="Center" 
-              IsChecked="{Binding Persist}"
-              Margin="5 3" ToolTip="Research each identification as they are selected"/>
+            <Button Grid.Row="0" Grid.Column="0" x:Name="SearchButton" Content="Search"
+                    VerticalAlignment="Center" Margin="5 3"
+                    VerticalContentAlignment="Center" Click="SearchWithNewIons_OnClick" />
 
-            <StackPanel Grid.Row="0" Grid.Column="2" Orientation="Horizontal" VerticalAlignment="Center">
-                <TextBlock Text="Set Dissociation Type: " VerticalAlignment="Center"/>
-                <ComboBox x:Name="DissociationTypeComboBox" ItemsSource="{Binding DissociationTypes}" 
-                  SelectedItem="{Binding SelectedDissociationType}" 
-                  Margin="5 3" VerticalContentAlignment="Center" Width="80" />
+            <CheckBox Grid.Row="0" Grid.Column="1" Content="Persist?" VerticalAlignment="Center"
+                      IsChecked="{Binding Persist}"
+                      Margin="5 3" ToolTip="Research each identification as they are selected" />
+
+            <StackPanel Grid.Row="0" Grid.Column="2" Orientation="Horizontal" VerticalAlignment="Center" HorizontalAlignment="Left">
+                <TextBlock Text="Set Dissociation Type: " VerticalAlignment="Center" />
+                <ComboBox x:Name="DissociationTypeComboBox" ItemsSource="{Binding DissociationTypes}"
+                          SelectedItem="{Binding SelectedDissociationType}"
+                          Margin="5 3" VerticalContentAlignment="Center" Width="80"
+                          HorizontalContentAlignment="Center"/>
+            </StackPanel>
+
+            <StackPanel Grid.Row="0" Grid.Column="3" Orientation="Horizontal" VerticalAlignment="Center" HorizontalAlignment="Left">
+                <TextBlock Text="Mass Tolerance (ppm): " VerticalAlignment="Center" />
+                <local:DoubleTextBoxControl Text="{Binding ProductIonMassTolerance, FallbackValue=20}"
+                                            HorizontalAlignment="Center" HorizontalContentAlignment="Center"
+                                            VerticalAlignment="Center" VerticalContentAlignment="Center"
+                                            BorderThickness="1" />
             </StackPanel>
-            <StackPanel Grid.Row="0" Grid.Column="3" Orientation="Horizontal" VerticalAlignment="Center">
-                <CheckBox Content="Use internal ions of minimum length " IsChecked="{Binding UseInternalIons}" 
-                  HorizontalContentAlignment="Right" VerticalAlignment="Center" />
-                <local:IntegerTexBoxControl Text="{Binding MinInternalIonLength, FallbackValue=10}" 
-            HorizontalAlignment="Center" HorizontalContentAlignment="Center"  IsEnabled="{Binding UseInternalIons}"
-            VerticalAlignment="Center" VerticalContentAlignment="Center" BorderThickness="1" />
+
+            <StackPanel Grid.Row="0" Grid.Column="4" Orientation="Horizontal" VerticalAlignment="Center" HorizontalAlignment="Left">
+                <CheckBox Content="Use internal ions of minimum length " IsChecked="{Binding UseInternalIons}"
+                          HorizontalContentAlignment="Right" VerticalAlignment="Center" />
+                <local:IntegerTexBoxControl Text="{Binding MinInternalIonLength, FallbackValue=10}"
+                                            HorizontalAlignment="Center" HorizontalContentAlignment="Center"
+                                            IsEnabled="{Binding UseInternalIons}"
+                                            VerticalAlignment="Center" VerticalContentAlignment="Center"
+                                            BorderThickness="1" />
             </StackPanel>
         </Grid>
 
diff --git a/MetaMorpheus/GuiFunctions/MetaDraw/FragmentResearching/FragmentationReanalysisViewModel.cs b/MetaMorpheus/GuiFunctions/MetaDraw/FragmentResearching/FragmentationReanalysisViewModel.cs
index 70194fb1c..6e2315cde 100644
--- a/MetaMorpheus/GuiFunctions/MetaDraw/FragmentResearching/FragmentationReanalysisViewModel.cs
+++ b/MetaMorpheus/GuiFunctions/MetaDraw/FragmentResearching/FragmentationReanalysisViewModel.cs
@@ -8,6 +8,7 @@
 using EngineLayer;
 using iText.StyledXmlParser.Jsoup;
 using MassSpectrometry;
+using MzLibUtil;
 using Omics;
 using Omics.Fragmentation;
 using Proteomics.ProteolyticDigestion;
@@ -26,6 +27,7 @@ public FragmentationReanalysisViewModel(bool isProtein = true)
             _isProtein = isProtein;
             UseInternalIons = false;
             MinInternalIonLength = 10;
+            ProductIonMassTolerance = 20;
             if (isProtein)
             {
                 DissociationTypes = new ObservableCollection<DissociationType>(Enum.GetValues<DissociationType>()
@@ -91,6 +93,14 @@ public bool UseInternalIons
             set { _useInternalIons = value; OnPropertyChanged(nameof(UseInternalIons)); }
         }
 
+        private double _productIonMassTolerance;
+
+        public double ProductIonMassTolerance
+        {
+            get => _productIonMassTolerance;
+            set { _productIonMassTolerance = value; OnPropertyChanged(nameof(ProductIonMassTolerance)); }
+        }
+
         private IEnumerable<FragmentViewModel> GetPossibleProducts(bool isProtein)
         {
             foreach (var product in Enum.GetValues<ProductType>())
@@ -211,13 +221,15 @@ public List<MatchedFragmentIon> MatchIonsWithNewTypes(MsDataScan ms2Scan, PsmFro
 
             // TODO: Adjust decon params for when RNA gets incorporated
             var commonParams = new CommonParameters();
+            if (Math.Abs(commonParams.ProductMassTolerance.Value - ProductIonMassTolerance) > 0.00001)
+                commonParams.ProductMassTolerance = new PpmTolerance(ProductIonMassTolerance);
+
             var specificMass = new Ms2ScanWithSpecificMass(ms2Scan, psmToRematch.PrecursorMz,
                 psmToRematch.PrecursorCharge, psmToRematch.FileNameWithoutExtension, commonParams);
 
             return MetaMorpheusEngine.MatchFragmentIons(specificMass, allProducts, commonParams, false)
                 .Union(psmToRematch.MatchedIons.Where(p => _productsToUse.Contains(p.NeutralTheoreticalProduct.ProductType)))
                 .ToList();
-            
         }
     }
 }
diff --git a/MetaMorpheus/GuiFunctions/MetaDraw/MetaDrawLogic.cs b/MetaMorpheus/GuiFunctions/MetaDraw/MetaDrawLogic.cs
index 3f953d065..a7deaa53b 100644
--- a/MetaMorpheus/GuiFunctions/MetaDraw/MetaDrawLogic.cs
+++ b/MetaMorpheus/GuiFunctions/MetaDraw/MetaDrawLogic.cs
@@ -781,7 +781,7 @@ public void FilterPsmsToChimerasOnly()
             {
                 FilteredListOfPsms.Clear();
 
-                var filteredChimericPsms = ChimericPsms.Where(p => MetaDrawSettings.FilterAcceptsPsm(p));
+                var filteredChimericPsms = ChimericPsms.Where(MetaDrawSettings.FilterAcceptsPsm);
                 foreach (var psm in filteredChimericPsms)
                 {
                     if (filteredChimericPsms.Count(p => p.Ms2ScanNumber == psm.Ms2ScanNumber && p.FileNameWithoutExtension == psm.FileNameWithoutExtension) > 1)
diff --git a/MetaMorpheus/GuiFunctions/MetaDraw/MetaDrawSettings.cs b/MetaMorpheus/GuiFunctions/MetaDraw/MetaDrawSettings.cs
index 3a47da2d1..38fb9ee8f 100644
--- a/MetaMorpheus/GuiFunctions/MetaDraw/MetaDrawSettings.cs
+++ b/MetaMorpheus/GuiFunctions/MetaDraw/MetaDrawSettings.cs
@@ -452,8 +452,9 @@ public static MetaDrawSettingsSnapshot MakeSnapShot()
         /// <summary>
         /// Loads in settings based upon SettingsSnapshot parameter
         /// </summary>
-        public static void LoadSettings(MetaDrawSettingsSnapshot settings)
+        public static void LoadSettings(MetaDrawSettingsSnapshot settings, out bool flaggedErrorOnRead)
         {
+            flaggedErrorOnRead = false;
             DisplayIonAnnotations = settings.DisplayIonAnnotations;
             AnnotateMzValues = settings.AnnotateMzValues;
             AnnotateCharges = settings.AnnotateCharges;
@@ -504,11 +505,15 @@ public static void LoadSettings(MetaDrawSettingsSnapshot settings)
 
                         break;
                     }
+                    default:
+                        throw new MetaMorpheusException("Cannot parse Product Ion Color values");
                 }
             }
             catch (Exception e)
             {
                 Debugger.Break();
+                SetDefaultProductTypeColors();
+                flaggedErrorOnRead = true;
             }
 
             try // Beta Product Type Colors
@@ -537,11 +542,15 @@ public static void LoadSettings(MetaDrawSettingsSnapshot settings)
 
                         break;
                     }
+                    default:
+                        throw new MetaMorpheusException("Cannot parse Beta Product Ion Color values");
                 }
             }
             catch (Exception e)
             {
                 Debugger.Break();
+                SetDefaultBetaProductTypeColors();
+                flaggedErrorOnRead = true;
             }
 
             try // Modification Type Colors
@@ -569,11 +578,15 @@ public static void LoadSettings(MetaDrawSettingsSnapshot settings)
 
                         break;
                     }
+                    default:
+                        throw new MetaMorpheusException("Cannot parse Modification Color values");
                 }
             }
             catch (Exception e)
             {
                 Debugger.Break();
+                SetDefaultModificationColors();
+                flaggedErrorOnRead = true;
             }
 
             try // Coverage Type Colors
@@ -598,18 +611,25 @@ public static void LoadSettings(MetaDrawSettingsSnapshot settings)
                             if (CoverageTypeToColor.ContainsKey(key))
                                 CoverageTypeToColor[key] = DrawnSequence.ParseOxyColorFromName(savedProductType.Split(',')[1]);
                         }
-
                         break;
                     }
+                    default:
+                        throw new MetaMorpheusException("Cannot parse Sequence Coverage color values");
+
                 }
             }
             catch (Exception e)
             {
-                Debugger.Break();
+                Debugger.Break(); 
+                SetDefaultCoverageTypeColors();
+                flaggedErrorOnRead = true;
             }
 
             try // Spectrum Descriptors
             {
+                if (!settings.SpectrumDescriptionValues.Any())
+                    throw new MetaMorpheusException("Cannot parse Spectrum Descriptor values");
+
                 var firstSplit = settings.SpectrumDescriptionValues.First().Split(',');
                 switch (firstSplit.Length)
                 {
@@ -633,11 +653,15 @@ public static void LoadSettings(MetaDrawSettingsSnapshot settings)
 
                         break;
                     }
+                    default:
+                        throw new MetaMorpheusException("Cannot parse Spectrum Descriptor values");
                 }
             }
             catch (Exception e)
             {
                 Debugger.Break();
+                SetDefaultProductTypeColors();
+                flaggedErrorOnRead = true;
             }
         }
 
diff --git a/MetaMorpheus/GuiFunctions/ViewModels/MetaDrawSettingsViewModel.cs b/MetaMorpheus/GuiFunctions/ViewModels/MetaDrawSettingsViewModel.cs
index 8ffe71a02..40f006bbe 100644
--- a/MetaMorpheus/GuiFunctions/ViewModels/MetaDrawSettingsViewModel.cs
+++ b/MetaMorpheus/GuiFunctions/ViewModels/MetaDrawSettingsViewModel.cs
@@ -182,7 +182,10 @@ public void LoadSettings()
         {
             MetaDrawSettingsSnapshot settings = null;
             settings = XmlReaderWriter.ReadFromXmlFile<MetaDrawSettingsSnapshot>(SettingsPath);
-            MetaDrawSettings.LoadSettings(settings);
+            MetaDrawSettings.LoadSettings(settings, out bool flaggedErrorOnRead);
+
+            if (flaggedErrorOnRead)
+                SaveAsDefault();
         }
 
       
diff --git a/MetaMorpheus/Test/MetaDraw/105MetaDrawSettingsSavedEditedForTestCoverageFailures.xml b/MetaMorpheus/Test/MetaDraw/105MetaDrawSettingsSavedEditedForTestCoverageFailures.xml
index f706023ee..6a3ce89f9 100644
--- a/MetaMorpheus/Test/MetaDraw/105MetaDrawSettingsSavedEditedForTestCoverageFailures.xml
+++ b/MetaMorpheus/Test/MetaDraw/105MetaDrawSettingsSavedEditedForTestCoverageFailures.xml
@@ -24,6 +24,7 @@
 	<string>true</string>
     <string>true</string>
     <string>true</string>
+    <string>gobbledygook</string>
   </SpectrumDescriptionValues>
   <ProductTypeToColorValues>
     <string>Aqua</string>
@@ -3823,6 +3824,7 @@
     <string>Hullabaloo</string>
     <string>Aqua</string>
     <string>Aqua</string>
+    <string>Claptrap</string>
   </CoverageTypeToColorValues>
   <UnannotatedPeakColor>LightGray</UnannotatedPeakColor>
   <InternalIonColor>Purple</InternalIonColor>
diff --git a/MetaMorpheus/Test/MetaDraw/FragmentReanalysis.cs b/MetaMorpheus/Test/MetaDraw/FragmentReanalysis.cs
index e91eeca48..4f508f134 100644
--- a/MetaMorpheus/Test/MetaDraw/FragmentReanalysis.cs
+++ b/MetaMorpheus/Test/MetaDraw/FragmentReanalysis.cs
@@ -29,11 +29,12 @@ public static void TestFragmentationReanalysisViewModel_DefaultProperties()
             var viewModel = new FragmentationReanalysisViewModel();
 
             // check default parameters on loading
-            Assert.That(viewModel.SelectedDissociationType, Is.EqualTo(DissociationType.HCD));
+            Assert.AreEqual(DissociationType.HCD, viewModel.SelectedDissociationType);
             Assert.False(viewModel.Persist);
             Assert.False(viewModel.UseInternalIons);
-            Assert.That(viewModel.MinInternalIonLength, Is.EqualTo(10));
-            Assert.That(viewModel.DissociationTypes.Count(), Is.EqualTo(7));
+            Assert.AreEqual(10, viewModel.MinInternalIonLength);
+            Assert.AreEqual(7, viewModel.DissociationTypes.Count());
+            Assert.AreEqual(20, viewModel.ProductIonMassTolerance);
 
             var productsToUse = viewModel.PossibleProducts.Where(p => p.Use).Select(p => p.ProductType).ToList();
             var hcdProducts = Omics.Fragmentation.Peptide.DissociationTypeCollection.ProductsFromDissociationType[DissociationType.HCD];
@@ -97,13 +98,24 @@ public static void TestFragmentationReanalysisViewModel_RematchIons()
             var psmToResearch = parsedPsms.First();
             var scan = dataFile.GetOneBasedScan(psmToResearch.Ms2ScanNumber);
 
+            // increase product ion tolerance and ensure more ions are found
+            viewModel.ProductIonMassTolerance = 200;
+            var newMatchedIons = viewModel.MatchIonsWithNewTypes(scan, psmToResearch);
+            Assert.Less(psmToResearch.MatchedIons.Count, newMatchedIons.Count);
+
+            // decrease product ion tolerance and ensure fewer ions are found
+            viewModel.ProductIonMassTolerance = 2;
+            newMatchedIons = viewModel.MatchIonsWithNewTypes(scan, psmToResearch);
+            Assert.Less(newMatchedIons.Count, psmToResearch.MatchedIons.Count);
+            viewModel.ProductIonMassTolerance = 20;
+
             // ensure ambiguous psms get kicked out before reanalysis
             var ambiguousPsm = parsedPsms.First(p => p.FullSequence.Contains('|'));
             var newIons = viewModel.MatchIonsWithNewTypes(scan, ambiguousPsm);
             CollectionAssert.AreEqual(ambiguousPsm.MatchedIons, newIons);
 
             viewModel.PossibleProducts.ForEach(p => p.Use = true);
-            var newMatchedIons = viewModel.MatchIonsWithNewTypes(scan, psmToResearch);
+            newMatchedIons = viewModel.MatchIonsWithNewTypes(scan, psmToResearch);
 
             // searching with additional ions should yield more 
             Assert.That(psmToResearch.MatchedIons.Count, Is.LessThan(newMatchedIons.Count));
diff --git a/MetaMorpheus/Test/MetaDraw/MetaDrawSettingsAndViewsTest.cs b/MetaMorpheus/Test/MetaDraw/MetaDrawSettingsAndViewsTest.cs
index c9ebd9b9e..c94868f6b 100644
--- a/MetaMorpheus/Test/MetaDraw/MetaDrawSettingsAndViewsTest.cs
+++ b/MetaMorpheus/Test/MetaDraw/MetaDrawSettingsAndViewsTest.cs
@@ -82,7 +82,8 @@ public static void TestMetaDrawSettingsSnapshot()
             snapshot.ShowLegend = false;
             snapshot.DrawNumbersUnderStationary = false;
             snapshot.SubAndSuperScriptIons = false;
-            MetaDrawSettings.LoadSettings(snapshot);
+            MetaDrawSettings.LoadSettings(snapshot, out bool flaggedError);
+            Assert.That(!flaggedError);
             Assert.That(snapshot.DisplayIonAnnotations.Equals(MetaDrawSettings.DisplayIonAnnotations));
             Assert.That(snapshot.AnnotateMzValues.Equals(MetaDrawSettings.AnnotateMzValues));
             Assert.That(snapshot.AnnotateCharges.Equals(MetaDrawSettings.AnnotateCharges));
@@ -115,7 +116,8 @@ public static void TestMetaDrawSettingsSnapshot()
             snapshot.AxisTitleTextSize = 0;
             snapshot.StrokeThicknessAnnotated = 0;
             snapshot.StrokeThicknessUnannotated = 0;
-            MetaDrawSettings.LoadSettings(snapshot);
+            MetaDrawSettings.LoadSettings(snapshot, out flaggedError);
+            Assert.That(!flaggedError);
             Assert.That(MetaDrawSettings.AnnotatedFontSize, Is.EqualTo(14));
             Assert.That(MetaDrawSettings.AxisLabelTextSize, Is.EqualTo(12));
             Assert.That(MetaDrawSettings.AxisTitleTextSize, Is.EqualTo(14));
@@ -188,6 +190,78 @@ public static void TestSettingsViewLoading()
             Assert.That(BlankSettingsView.CanOpen);
         }
 
+
+        [Test]
+        public static void TestLoadMetaDrawSettings()
+        {
+            // Set up testing environment
+            var metaDrawTestingDirectory = Path.Combine(TestContext.CurrentContext.TestDirectory, "MetaDraw");
+            var testingDir = Path.Combine(metaDrawTestingDirectory, "TempTestData");
+            if (Directory.Exists(testingDir))
+                Directory.Delete(testingDir, true);
+            Directory.CreateDirectory(testingDir);
+
+            var masterSettings = Path.Combine(metaDrawTestingDirectory, @"105MetaDrawSettingsSaved.xml");
+            string outdatedSettingsPath = Path.Combine(testingDir, @"105MetaDrawSettingsSaved_COPY.xml");
+            File.Copy(masterSettings, outdatedSettingsPath);
+
+            // Save default values currently stored in MetaDrawSettings
+            var defaultCoverageColors = MetaDrawSettings.CoverageTypeToColor.Values.ToList();
+            var defaultColorValues = MetaDrawSettings.ProductTypeToColor.Values.ToList();
+
+            // CASE: user does not have a settings config file stored
+            // Desired outcome: All default values are used
+            MetaDrawSettingsViewModel viewModel = new MetaDrawSettingsViewModel(false);
+            var modelSettingsPath = MetaDrawSettingsViewModel.SettingsPath;
+            Assert.False(File.Exists(modelSettingsPath));
+            NUnit.Framework.Assert.That(!viewModel.HasDefaultSaved);
+
+            Assert.AreEqual(MetaDrawSettings.CoverageTypeToColor.Values.ElementAt(0), defaultCoverageColors[0]);
+            Assert.AreEqual(MetaDrawSettings.CoverageTypeToColor.Values.ElementAt(1), defaultCoverageColors[1]);
+            Assert.AreEqual(MetaDrawSettings.CoverageTypeToColor.Values.ElementAt(2), defaultCoverageColors[2]);
+
+                // Make one change and save this viewModel as a modern settings config for next test case
+            viewModel.CoverageColors.First().SelectionChanged("Yellow");
+            string modernSettingsPath = Path.Combine(testingDir, "temporaryCurrentSettingsConfig.xml");
+            MetaDrawSettingsViewModel.SettingsPath = modernSettingsPath;
+            viewModel.SaveAsDefault();
+
+            // CASE: user has modern settings config file stored
+            // Desired outcome: Read in correctly 
+            modelSettingsPath = MetaDrawSettingsViewModel.SettingsPath;
+            Assert.True(File.Exists(modelSettingsPath));
+            var creationTime = File.GetLastWriteTime(modernSettingsPath);
+            viewModel = new MetaDrawSettingsViewModel(false);
+                // check that no new file was generated
+            var creationTimeAfterLoad = File.GetLastWriteTime(modernSettingsPath);
+            Assert.AreEqual(creationTimeAfterLoad, creationTime);
+            
+            Assert.AreNotEqual(MetaDrawSettings.CoverageTypeToColor.Values.ElementAt(0), defaultCoverageColors[0]);
+            Assert.AreEqual(MetaDrawSettings.CoverageTypeToColor.Values.ElementAt(0), OxyColors.Yellow);
+            Assert.AreEqual(MetaDrawSettings.CoverageTypeToColor.Values.ElementAt(1), defaultCoverageColors[1]);
+            Assert.AreEqual(MetaDrawSettings.CoverageTypeToColor.Values.ElementAt(2), defaultCoverageColors[2]);
+
+
+            // CASE: user has old settings config file stored
+            // Desired outcome: We use what we can salvage, default the rest, delete old file, replace with modern
+            MetaDrawSettingsViewModel.SettingsPath = outdatedSettingsPath;
+
+            // Ensure settings are in outdated format
+            int commaCount = File.ReadLines(outdatedSettingsPath).Sum(p => p.Count(m => m.Equals(',')));
+            Assert.AreEqual(0, commaCount);
+
+            creationTime = File.GetLastWriteTime(outdatedSettingsPath);
+            viewModel = new MetaDrawSettingsViewModel(false);
+            creationTimeAfterLoad = File.GetLastWriteTime(outdatedSettingsPath);
+            Assert.AreNotEqual(creationTimeAfterLoad, creationTime);
+
+            Assert.AreEqual(MetaDrawSettings.ProductTypeToColor.Values.ElementAt(0), defaultColorValues[0]);
+            Assert.AreEqual(MetaDrawSettings.ProductTypeToColor.Values.ElementAt(1), defaultColorValues[1]);
+            Assert.AreEqual(MetaDrawSettings.ProductTypeToColor.Values.ElementAt(2), defaultColorValues[2]);
+
+            Directory.Delete(testingDir, true);
+        }
+
         [Test]
         public static void TestOldMetaDrawSettingsFileDoesNotCrash()
         {
@@ -232,11 +306,13 @@ public static void TestMetaDrawSettingsLoadSettingsCases()
         {
             string path = Path.Combine(TestContext.CurrentContext.TestDirectory, "MetaDraw", @"105MetaDrawSettingsSavedEditedForTestCoverageFailures.xml");
             var snapShot = XmlReaderWriter.ReadFromXmlFile<MetaDrawSettingsSnapshot>(path);
-            MetaDrawSettings.LoadSettings(snapShot);
+            MetaDrawSettings.LoadSettings(snapShot, out bool flaggedError);
+            Assert.That(flaggedError);
 
             path = Path.Combine(TestContext.CurrentContext.TestDirectory, "MetaDraw", @"105MetaDrawSettingsSavedEditedForTestCoverageSuccess.xml");
             snapShot = XmlReaderWriter.ReadFromXmlFile<MetaDrawSettingsSnapshot>(path);
-            MetaDrawSettings.LoadSettings(snapShot);
+            MetaDrawSettings.LoadSettings(snapShot, out flaggedError);
+            Assert.That(flaggedError);
         }
 
         [Test]