diff --git a/KeeOneDriveSync.plgx b/KeeOneDriveSync.plgx
index fdab2b2..49c5892 100644
Binary files a/KeeOneDriveSync.plgx and b/KeeOneDriveSync.plgx differ
diff --git a/KoenZomers.KeePass.OneDriveSync/Configuration.cs b/KoenZomers.KeePass.OneDriveSync/Configuration.cs
index 3003ebc..a62d6eb 100644
--- a/KoenZomers.KeePass.OneDriveSync/Configuration.cs
+++ b/KoenZomers.KeePass.OneDriveSync/Configuration.cs
@@ -40,6 +40,11 @@ public class Configuration : ICloneable
         /// </summary>
         public KeePassLib.PwDatabase KeePassDatabase { get; set; }
 
+        /// <summary>
+        /// Boolean indicating if this database is currently synchronizing
+        /// </summary>
+        public bool IsCurrentlySyncing { get; set; }
+
         #endregion
 
         #region Serializable Properties
diff --git a/KoenZomers.KeePass.OneDriveSync/Enums/CloudStorageType.cs b/KoenZomers.KeePass.OneDriveSync/Enums/CloudStorageType.cs
index 4ae0568..d2017da 100644
--- a/KoenZomers.KeePass.OneDriveSync/Enums/CloudStorageType.cs
+++ b/KoenZomers.KeePass.OneDriveSync/Enums/CloudStorageType.cs
@@ -23,6 +23,11 @@ public enum CloudStorageType : short
         /// <summary>
         /// Microsoft SharePoint
         /// </summary>
-        SharePoint
+        SharePoint = 3,
+
+        /// <summary>
+        /// Do not sync
+        /// </summary>
+        None = 99
     }
 }
diff --git a/KoenZomers.KeePass.OneDriveSync/Forms/OneDriveAskToStartSyncingDialog.cs b/KoenZomers.KeePass.OneDriveSync/Forms/OneDriveAskToStartSyncingDialog.cs
index d693a1c..c82ccad 100644
--- a/KoenZomers.KeePass.OneDriveSync/Forms/OneDriveAskToStartSyncingDialog.cs
+++ b/KoenZomers.KeePass.OneDriveSync/Forms/OneDriveAskToStartSyncingDialog.cs
@@ -34,7 +34,7 @@ private void OKButton_Click(object sender, EventArgs e)
             {
                 _configuration.DoNotSync = NoNeverAskAgainRadio.Checked;
                 Configuration.Save();
-                DialogResult = DialogResult.Cancel;
+                DialogResult = DialogResult.OK;
             }
 
             Close();
diff --git a/KoenZomers.KeePass.OneDriveSync/KeePassDatabase.cs b/KoenZomers.KeePass.OneDriveSync/KeePassDatabase.cs
index 5f42978..27388d3 100644
--- a/KoenZomers.KeePass.OneDriveSync/KeePassDatabase.cs
+++ b/KoenZomers.KeePass.OneDriveSync/KeePassDatabase.cs
@@ -85,42 +85,51 @@ public static async Task SyncDatabase(string localKeePassDatabasePath, Action<st
         {
             try
             {
-                // If something is already syncing, abort this attempt. This happens when the Import saves the resulting KeePass database. That by itself triggers another sync which doesn't have to go through the sync process as it just regards the temp database.
-                if (KoenZomersKeePassOneDriveSyncExt.IsSomethingStillRunning)
-                {
-                    UpdateStatus("A synchronization is already in progress");
-                    return;
-                }
-
-                // Set flag to block exiting KeePass until this is done
-                KoenZomersKeePassOneDriveSyncExt.IsSomethingStillRunning = true;
-
-                UpdateStatus("Starting database synchronization");
-
                 // Retrieve the KeePassOneDriveSync settings
                 if (databaseConfig == null)
                 {
                     databaseConfig = Configuration.GetPasswordDatabaseConfiguration(localKeePassDatabasePath);
                 }
 
+                // If this database is already syncing, abort this attempt. This happens when the Import saves the resulting KeePass database. That by itself triggers another sync which doesn't have to go through the sync process as it just regards the temp database.
+                if (databaseConfig.IsCurrentlySyncing)
+                {
+                    UpdateStatus(string.Format("A synchronization is already in progress for database {0}", databaseConfig.KeePassDatabase.Name));
+                    return;
+                }                
+
                 // Check if this database explicitly does not allow to be synced with OneDrive and if syncing is enabled on this database
                 if (databaseConfig.DoNotSync || !databaseConfig.SyncingEnabled)
                 {
-                    // Set flag to allow exiting KeePass
-                    KoenZomersKeePassOneDriveSyncExt.IsSomethingStillRunning = false;
-
                     return;
                 }
 
+                UpdateStatus(string.Format("Starting database synchronization for database {0}", databaseConfig.KeePassDatabase.Name));
+                databaseConfig.IsCurrentlySyncing = true;
+
                 // Check if the current database is synced with OneDrive
                 if (string.IsNullOrEmpty(databaseConfig.RemoteDatabasePath) && string.IsNullOrEmpty(databaseConfig.RemoteFolderId) && string.IsNullOrEmpty(databaseConfig.RemoteFileName))
                 {
                     var cloudStorageType = AskIfShouldBeSynced(databaseConfig);
-
+                    
                     if(!cloudStorageType.HasValue)
                     {
-                        // Set flag to allow exiting KeePass
-                        KoenZomersKeePassOneDriveSyncExt.IsSomethingStillRunning = false;
+                        // No decission has been taken whether to sync the database or not
+                        // Set flag to indicate that the database is currently not syncing
+                        databaseConfig.IsCurrentlySyncing = false;
+
+                        UpdateStatus(string.Format("Canceled database synchronization for database {0}", databaseConfig.KeePassDatabase.Name));
+
+                        return;
+                    }
+                    if (cloudStorageType.Value == CloudStorageType.None)
+                    {
+                        // Database should not be synchronized
+                        // Set flag to indicate that the database is currently not syncing
+                        databaseConfig.IsCurrentlySyncing = false;
+
+                        UpdateStatus(string.Format("Database {0} will not be synchronized", databaseConfig.KeePassDatabase.Name));
+
                         return;
                     }
 
@@ -147,14 +156,14 @@ public static async Task SyncDatabase(string localKeePassDatabasePath, Action<st
                 if(!syncSuccessful)
                 {
                     // Set flag to allow exiting KeePass
-                    KoenZomersKeePassOneDriveSyncExt.IsSomethingStillRunning = false;
+                    databaseConfig.IsCurrentlySyncing = false;
                     return;
                 }
 
                 // Update the KeePass UI so it shows the new entries
                 KoenZomersKeePassOneDriveSyncExt.Host.MainWindow.UpdateUI(false, null, true, null, true, null, false);
 
-                updateStatus("KeePass database has successfully been synchronized and uploaded");
+                updateStatus(string.Format("KeePass database {0} has successfully been synchronized and uploaded", databaseConfig.KeePassDatabase.Name));
 
                 databaseConfig.LocalFileHash = Utilities.GetDatabaseFileHash(localKeePassDatabasePath);
                 //databaseConfig.ETag = uploadResult.ETag;
@@ -164,11 +173,11 @@ public static async Task SyncDatabase(string localKeePassDatabasePath, Action<st
             }
             catch(Exception e)
             {
-                updateStatus(string.Concat("Failed to sync database: ", e.Message));
+                updateStatus(string.Format("Failed to sync database {0}: {1}", databaseConfig.KeePassDatabase.Name, e.Message));
             }
 
             // Set flag to allow exiting KeePass
-            KoenZomersKeePassOneDriveSyncExt.IsSomethingStillRunning = false;
+            databaseConfig.IsCurrentlySyncing = false;
         }
 
         /// <summary>
@@ -186,8 +195,14 @@ public static async Task SyncDatabase(string localKeePassDatabasePath, Action<st
                 return null;
             }
 
+            if(databaseConfig.DoNotSync)
+            {
+                // Don't sync and don't ask again has been chosen
+                return CloudStorageType.None;
+            }
+
             // Ask which cloud service to connect to
-            var oneDriveCloudTypeForm = new OneDriveCloudTypeForm { ExplanationText = "Choose the cloud service you wish to store the KeePass database on:" };
+            var oneDriveCloudTypeForm = new OneDriveCloudTypeForm { ExplanationText = string.Format("Choose the cloud service you wish to store the KeePass database {0} on:", databaseConfig.KeePassDatabase.Name) };
             if (oneDriveCloudTypeForm.ShowDialog() != DialogResult.OK)
             {
                 // Dialog has been canceled. Return NULL to indicate no choice has been made.
@@ -212,7 +227,7 @@ public static bool MergeDatabases(Configuration databaseConfig, string tempDatab
             databaseConfig.SyncingEnabled = false;
 
             // Import the current database with the downloaded database. Import causes a one way sync, syncing would try to update both ends which won't work for OneDrive.
-            var importSuccessful = ImportUtil.Import(KoenZomersKeePassOneDriveSyncExt.Host.Database, formatter, new[] { connectionInfo }, true, KoenZomersKeePassOneDriveSyncExt.Host.MainWindow, false, KoenZomersKeePassOneDriveSyncExt.Host.MainWindow);
+            var importSuccessful = ImportUtil.Import(databaseConfig.KeePassDatabase, formatter, new[] { connectionInfo }, true, KoenZomersKeePassOneDriveSyncExt.Host.MainWindow, false, KoenZomersKeePassOneDriveSyncExt.Host.MainWindow);
 
             // Enable syncing of this database again
             databaseConfig.SyncingEnabled = true;
diff --git a/KoenZomers.KeePass.OneDriveSync/KoenZomersKeePassOneDriveSyncExt.cs b/KoenZomers.KeePass.OneDriveSync/KoenZomersKeePassOneDriveSyncExt.cs
index ae37a30..e2c2ae7 100644
--- a/KoenZomers.KeePass.OneDriveSync/KoenZomersKeePassOneDriveSyncExt.cs
+++ b/KoenZomers.KeePass.OneDriveSync/KoenZomersKeePassOneDriveSyncExt.cs
@@ -78,7 +78,13 @@ public class KoenZomersKeePassOneDriveSyncExt : Plugin
         /// <summary>
         /// Boolean to indicate if some process is still running that we need to wait for before we shut down KeePass
         /// </summary>
-        internal static bool IsSomethingStillRunning { get; set; }
+        internal static bool IsSomethingStillRunning
+        {
+            get
+            {
+                return Configuration.PasswordDatabases.Any(db => db.Value.IsCurrentlySyncing);
+            }
+        }
 
         #endregion
 
@@ -209,7 +215,12 @@ private async void MainWindowOnFileSaved(object sender, FileSavedEventArgs fileS
             config.KeePassDatabase = fileSavedEventArgs.Database;
 
             // Check if we should sync this database
-            if (config.DoNotSync || !_fileOfflineMenuItem.Checked) return;
+            if (config.DoNotSync) return;
+            if(!_fileOfflineMenuItem.Checked)
+            {
+                Host.MainWindow.SetStatusEx(string.Format("OneDriveSync has been set to offline, skipping sync for database {0}", fileSavedEventArgs.Database.Name));
+                return;
+            }
 
             // Make sure it's not a remote database on i.e. an FTP or website
             if (!fileSavedEventArgs.Database.IOConnectionInfo.IsLocalFile())
@@ -274,7 +285,12 @@ private async void OnKeePassDatabaseOpened(object sender, FileOpenedEventArgs fi
             config.KeePassDatabase = fileOpenedEventArgs.Database;
 
             // Check if we should sync this database
-            if (config.DoNotSync || !fileOpenedEventArgs.Database.IOConnectionInfo.IsLocalFile() || !_fileOfflineMenuItem.Checked) return;
+            if (config.DoNotSync || !fileOpenedEventArgs.Database.IOConnectionInfo.IsLocalFile()) return;
+            if(!_fileOfflineMenuItem.Checked)
+            {
+                Host.MainWindow.SetStatusEx(string.Format("OneDriveSync has been set to offline, skipping sync for database {0}", fileOpenedEventArgs.Database.Name));
+                return;
+            }
 
             // Check if the database configuration of the opened KeePass database is set to retrieve the OneDrive Refresh Token from the KeePass database itself
             if (config.RefreshTokenStorage == OneDriveRefreshTokenStorage.KeePassDatabase && string.IsNullOrEmpty(config.RefreshToken))
diff --git a/KoenZomers.KeePass.OneDriveSync/Properties/AssemblyInfo.cs b/KoenZomers.KeePass.OneDriveSync/Properties/AssemblyInfo.cs
index e916fc4..ea472c9 100644
--- a/KoenZomers.KeePass.OneDriveSync/Properties/AssemblyInfo.cs
+++ b/KoenZomers.KeePass.OneDriveSync/Properties/AssemblyInfo.cs
@@ -31,4 +31,4 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("2.0.4.2")]
+[assembly: AssemblyVersion("2.0.5.0")]
diff --git a/KoenZomers.KeePass.OneDriveSync/Providers/OneDriveProvider.cs b/KoenZomers.KeePass.OneDriveSync/Providers/OneDriveProvider.cs
index de6d660..8a7eee7 100644
--- a/KoenZomers.KeePass.OneDriveSync/Providers/OneDriveProvider.cs
+++ b/KoenZomers.KeePass.OneDriveSync/Providers/OneDriveProvider.cs
@@ -56,6 +56,7 @@ public static async Task<bool> SyncUsingOneDriveCloudProvider(Configuration data
                             errorMessage.Append("cloud storage provider");
                             break;
                     }
+                    errorMessage.AppendLine(string.Format(" for database {0}", databaseConfig.KeePassDatabase.Name));
                     errorMessage.AppendLine(":");
                     errorMessage.AppendLine();
                     errorMessage.AppendLine(e.Message);
@@ -82,10 +83,10 @@ public static async Task<bool> SyncUsingOneDriveCloudProvider(Configuration data
             {
                 switch (databaseConfig.CloudStorageType.GetValueOrDefault(CloudStorageType.OneDriveConsumer))
                 {
-                    case CloudStorageType.OneDriveConsumer: updateStatus("Failed to connect to OneDrive"); break;
-                    case CloudStorageType.OneDriveForBusiness: updateStatus("Failed to connect to OneDrive for Business"); break;
-                    case CloudStorageType.MicrosoftGraph: updateStatus("Failed to connect to Microsoft Graph"); break;
-                    default: updateStatus("Failed to connect to cloud service"); break;
+                    case CloudStorageType.OneDriveConsumer: updateStatus(string.Format("Failed to connect to OneDrive for database {0}", databaseConfig.KeePassDatabase.Name)); break;
+                    case CloudStorageType.OneDriveForBusiness: updateStatus(string.Format("Failed to connect to OneDrive for Business for database {0}", databaseConfig.KeePassDatabase.Name)); break;
+                    case CloudStorageType.MicrosoftGraph: updateStatus(string.Format("Failed to connect to Microsoft Graph for database {0}", databaseConfig.KeePassDatabase.Name)); break;
+                    default: updateStatus(string.Format("Failed to connect to cloud service for database {0}", databaseConfig.KeePassDatabase.Name)); break;
                 }
 
                 return false;
@@ -155,7 +156,7 @@ public static async Task<bool> SyncUsingOneDriveCloudProvider(Configuration data
 
                         if (folder == null)
                         {
-                            updateStatus("Unable to download database from OneDrive. Remote path cannot be found.");
+                            updateStatus(string.Format("Unable to download database {0} from OneDrive. Remote path cannot be found.", databaseConfig.KeePassDatabase.Name));
                             return false;
                         }
 
@@ -198,7 +199,7 @@ public static async Task<bool> SyncUsingOneDriveCloudProvider(Configuration data
             if (oneDriveItem == null)
             {
                 // KeePass database not found on OneDrive
-                updateStatus("Database does not exist yet on OneDrive, uploading it now");
+                updateStatus(string.Format("Database {0} does not exist yet on OneDrive, uploading it now", databaseConfig.KeePassDatabase.Name));
 
                 OneDriveItem oneDriveFolder;
                 string fileName;
@@ -215,14 +216,14 @@ public static async Task<bool> SyncUsingOneDriveCloudProvider(Configuration data
 
                 if (oneDriveFolder == null)
                 {
-                    updateStatus("Unable to upload database to OneDrive. Remote path is invalid.");
+                    updateStatus(string.Format("Unable to upload database {0} to OneDrive. Remote path is invalid.", databaseConfig.KeePassDatabase.Name));
                     return false;
                 }
 
                 // Upload the database to OneDrive                
                 var newUploadResult = await oneDriveApi.UploadFileAs(localKeePassDatabasePath, fileName, oneDriveFolder);
 
-                updateStatus(newUploadResult == null ? "Failed to upload the KeePass database" : "Successfully uploaded the new KeePass database to OneDrive");
+                updateStatus(string.Format(newUploadResult == null ? "Failed to upload the KeePass database {0}" : "Successfully uploaded the new KeePass database {0} to OneDrive", databaseConfig.KeePassDatabase.Name));
 
                 databaseConfig.LocalFileHash = Utilities.GetDatabaseFileHash(localKeePassDatabasePath);
                 if (newUploadResult != null)
@@ -241,7 +242,7 @@ public static async Task<bool> SyncUsingOneDriveCloudProvider(Configuration data
             if (!forceSync && 
                 oneDriveItem.CTag == databaseConfig.ETag)
             {
-                updateStatus("Databases are in sync");
+                updateStatus(string.Format("Database {0} is in sync", databaseConfig.KeePassDatabase.Name));
 
                 databaseConfig.LastCheckedAt = DateTime.Now;
                 Configuration.Save();
@@ -250,41 +251,41 @@ public static async Task<bool> SyncUsingOneDriveCloudProvider(Configuration data
             }
 
             // Download the database from OneDrive
-            updateStatus("Downloading KeePass database from OneDrive");
+            updateStatus(string.Format("Downloading KeePass database {0} from OneDrive", databaseConfig.KeePassDatabase.Name));
 
             var temporaryKeePassDatabasePath = System.IO.Path.GetTempFileName();
             var downloadSuccessful = await oneDriveApi.DownloadItemAndSaveAs(oneDriveItem, temporaryKeePassDatabasePath);
 
             if (!downloadSuccessful)
             {
-                updateStatus("Failed to download the KeePass database from OneDrive");
+                updateStatus(string.Format("Failed to download the KeePass database {0} from OneDrive", databaseConfig.KeePassDatabase.Name));
 
                 return false;
             }
 
             // Sync database
-            updateStatus("KeePass database downloaded, going to sync");
+            updateStatus(string.Format("KeePass database {0} downloaded, going to sync", databaseConfig.KeePassDatabase.Name));
 
             // Ensure the database that needs to be synced is still the database currently selected in KeePass to avoid merging the downloaded database with the wrong database in KeePass
-            if ((!KoenZomersKeePassOneDriveSyncExt.Host.Database.IOConnectionInfo.Path.StartsWith(AppDomain.CurrentDomain.BaseDirectory) && KoenZomersKeePassOneDriveSyncExt.Host.Database.IOConnectionInfo.Path != localKeePassDatabasePath) ||
-                (KoenZomersKeePassOneDriveSyncExt.Host.Database.IOConnectionInfo.Path.StartsWith(AppDomain.CurrentDomain.BaseDirectory) && KoenZomersKeePassOneDriveSyncExt.Host.Database.IOConnectionInfo.Path.Remove(0, AppDomain.CurrentDomain.BaseDirectory.Length) != localKeePassDatabasePath))
-            {                
-                updateStatus("Failed to sync. Please don't switch to another database before done.");
+            //if ((!KoenZomersKeePassOneDriveSyncExt.Host.Database.IOConnectionInfo.Path.StartsWith(AppDomain.CurrentDomain.BaseDirectory) && KoenZomersKeePassOneDriveSyncExt.Host.Database.IOConnectionInfo.Path != localKeePassDatabasePath) ||
+            //    (KoenZomersKeePassOneDriveSyncExt.Host.Database.IOConnectionInfo.Path.StartsWith(AppDomain.CurrentDomain.BaseDirectory) && KoenZomersKeePassOneDriveSyncExt.Host.Database.IOConnectionInfo.Path.Remove(0, AppDomain.CurrentDomain.BaseDirectory.Length) != localKeePassDatabasePath))
+            //{                
+            //    updateStatus("Failed to sync. Please don't switch to another database before done.");
 
-                return false;
-            }
+            //    return false;
+            //}
 
             // Merge the downloaded database with the currently open KeePass database
             var syncSuccessful = KeePassDatabase.MergeDatabases(databaseConfig, temporaryKeePassDatabasePath);
 
             if (!syncSuccessful)
             {
-                updateStatus("Failed to synchronize the KeePass databases");
+                updateStatus(string.Format("Failed to synchronize the KeePass database {0}", databaseConfig.KeePassDatabase.Name));
                 return false;
             }
 
             // Upload the synced database
-            updateStatus("Uploading the new KeePass database to OneDrive");
+            updateStatus(string.Format("Uploading the new KeePass database {0} to OneDrive", databaseConfig.KeePassDatabase.Name));
 
             OneDriveItem uploadResult = null;
 
@@ -331,13 +332,13 @@ public static async Task<bool> SyncUsingOneDriveCloudProvider(Configuration data
                         throw;
                     }
 
-                    updateStatus(string.Format("Uploading the new KeePass database to OneDrive (attempt {0})", uploadAttempts + 1));
+                    updateStatus(string.Format("Uploading the new KeePass database {1} to OneDrive (attempt {0})", uploadAttempts + 1, databaseConfig.KeePassDatabase.Name));
                 }
             }
 
             if (uploadResult == null)
             {
-                updateStatus("Failed to upload the KeePass database");
+                updateStatus(string.Format("Failed to upload the KeePass database {0}", databaseConfig.KeePassDatabase.Name));
                 return false;
             }
 
@@ -454,9 +455,9 @@ public static async Task<string> OpenFromOneDriveCloudProvider(Configuration dat
                 // KeePass database not found on OneDrive
                 switch (databaseConfig.CloudStorageType.Value)
                 {
-                    case CloudStorageType.OneDriveConsumer: updateStatus("Unable to find the database on your OneDrive"); break;
-                    case CloudStorageType.OneDriveForBusiness: updateStatus("Unable to find the database on your OneDrive for Business"); break;
-                    case CloudStorageType.MicrosoftGraph: updateStatus("Unable to find the database through Microsoft Graph"); break;
+                    case CloudStorageType.OneDriveConsumer: updateStatus(string.Format("Unable to find the database {0} on your OneDrive", databaseConfig.KeePassDatabase.Name)); break;
+                    case CloudStorageType.OneDriveForBusiness: updateStatus(string.Format("Unable to find the database {0} on your OneDrive for Business", databaseConfig.KeePassDatabase.Name)); break;
+                    case CloudStorageType.MicrosoftGraph: updateStatus(string.Format("Unable to find the database {0} through Microsoft Graph", databaseConfig.KeePassDatabase.Name)); break;
                     default: updateStatus("Failed to connect to cloud service"); break;
                 }
                 return null;
@@ -474,12 +475,12 @@ public static async Task<string> OpenFromOneDriveCloudProvider(Configuration dat
             var saveFileDialogResult = saveFiledialog.ShowDialog();
             if (saveFileDialogResult != DialogResult.OK || string.IsNullOrEmpty(saveFiledialog.FileName))
             {
-                updateStatus("Open KeePass database from OneDrive aborted");
+                updateStatus(string.Format("Open KeePass database {0} from OneDrive aborted", databaseConfig.KeePassDatabase.Name));
                 return null;
             }
 
             // Download the KeePass database to the selected location
-            updateStatus("Downloading KeePass database");
+            updateStatus(string.Format("Downloading KeePass database {0}", databaseConfig.KeePassDatabase.Name));
             await oneDriveApi.DownloadItemAndSaveAs(oneDriveItem, saveFiledialog.FileName);
 
             // The ETag changes with every request of the item so we use the CTag instead which only changes when the file changes
diff --git a/README.md b/README.md
index 7f03aa4..5846931 100644
--- a/README.md
+++ b/README.md
@@ -17,6 +17,11 @@ Download the PLGX and place it inside your KeePass\Plugins folder. Typically thi
 
 ## Latest Version
 
+Version 2.0.5.0 - June 2, 2019
+
+- Added the ability to synchronize multiple KeePass databases at the same time. So you no longer get an error message if you're trying to sync a database which is not the currently active one. This is particularly useful when you use scripts or plugins to open multiple databases at once. They all should automatically sync now when they open.
+- Added a status message in the status bar or KeePass indicating that the sync is not happening when KeePassOneDriveSync has been set to offline mode so to visualize why a sync is not happening at that time
+
 Version 2.0.4.2 - May 22, 2019
 
 - Still was receiving reports on issues uploading larger than 5 MB databases. Did an additional fix hoping for it to have caught all scenarios this time. Discussed in [issue 88](https://github.com/KoenZomers/KeePassOneDriveSync/issues/88).