diff --git a/CHANGELOG.md b/CHANGELOG.md
index a60c25b248a..24732f17f0b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -41,6 +41,10 @@ Note that this project **does not** adhere to [Semantic Versioning](http://semve
 - We improved the Drag and Drop behavior in the "Customize Entry Types" Dialog [#6338](https://github.com/JabRef/jabref/issues/6338)
 - When determining the URL of an ArXiV eprint, the URL now points to the version [#8149](https://github.com/JabRef/jabref/pull/8149)
 - We Included all standard fields with citation key when exporting to Old OpenOffice/LibreOffice Calc Format [#8176](https://github.com/JabRef/jabref/pull/8176)
+- In case the database is encoded with `UTF8`, the `% Encoding` marker is not written anymore
+- The written `.bib` file has the same line endings [#390](https://github.com/koppor/jabref/issues/390)
+- The written `.bib` file always has a final line break
+- The written `.bib` file keeps the newline separator of the loaded `.bib` file
 - We present options to manually enter an article or return to the New Entry menu when the fetcher DOI fails to find an entry for an ID [#7870](https://github.com/JabRef/jabref/issues/7870)
 
 ### Fixed
diff --git a/src/jmh/java/org/jabref/benchmarks/Benchmarks.java b/src/jmh/java/org/jabref/benchmarks/Benchmarks.java
index 46ba83b2f89..b0073114ac5 100644
--- a/src/jmh/java/org/jabref/benchmarks/Benchmarks.java
+++ b/src/jmh/java/org/jabref/benchmarks/Benchmarks.java
@@ -9,6 +9,7 @@
 import java.util.stream.Collectors;
 
 import org.jabref.gui.Globals;
+import org.jabref.logic.exporter.BibWriter;
 import org.jabref.logic.exporter.BibtexDatabaseWriter;
 import org.jabref.logic.exporter.SavePreferences;
 import org.jabref.logic.formatter.bibtexfields.HtmlToLatexFormatter;
@@ -17,6 +18,7 @@
 import org.jabref.logic.layout.format.HTMLChars;
 import org.jabref.logic.layout.format.LatexToUnicodeFormatter;
 import org.jabref.logic.search.SearchQuery;
+import org.jabref.logic.util.OS;
 import org.jabref.model.database.BibDatabase;
 import org.jabref.model.database.BibDatabaseContext;
 import org.jabref.model.database.BibDatabaseMode;
@@ -77,7 +79,8 @@ public void init() throws Exception {
 
     private StringWriter getOutputWriter() throws IOException {
         StringWriter outputWriter = new StringWriter();
-        BibtexDatabaseWriter databaseWriter = new BibtexDatabaseWriter(outputWriter, mock(GeneralPreferences.class), mock(SavePreferences.class), new BibEntryTypesManager());
+        BibWriter bibWriter = new BibWriter(outputWriter, OS.NEWLINE);
+        BibtexDatabaseWriter databaseWriter = new BibtexDatabaseWriter(bibWriter, mock(GeneralPreferences.class), mock(SavePreferences.class), new BibEntryTypesManager());
         databaseWriter.savePartOfDatabase(new BibDatabaseContext(database, new MetaData()), database.getEntries());
         return outputWriter;
     }
diff --git a/src/main/java/org/jabref/cli/ArgumentProcessor.java b/src/main/java/org/jabref/cli/ArgumentProcessor.java
index 5cfc3e81cf0..74b9c84d3c2 100644
--- a/src/main/java/org/jabref/cli/ArgumentProcessor.java
+++ b/src/main/java/org/jabref/cli/ArgumentProcessor.java
@@ -22,6 +22,7 @@
 import org.jabref.logic.citationkeypattern.CitationKeyGenerator;
 import org.jabref.logic.exporter.AtomicFileWriter;
 import org.jabref.logic.exporter.BibDatabaseWriter;
+import org.jabref.logic.exporter.BibWriter;
 import org.jabref.logic.exporter.BibtexDatabaseWriter;
 import org.jabref.logic.exporter.EmbeddedBibFilePdfExporter;
 import org.jabref.logic.exporter.Exporter;
@@ -531,7 +532,8 @@ private void saveDatabase(BibDatabase newBase, String subName) {
             GeneralPreferences generalPreferences = preferencesService.getGeneralPreferences();
             SavePreferences savePreferences = preferencesService.getSavePreferences();
             AtomicFileWriter fileWriter = new AtomicFileWriter(Path.of(subName), generalPreferences.getDefaultEncoding());
-            BibDatabaseWriter databaseWriter = new BibtexDatabaseWriter(fileWriter, generalPreferences, savePreferences, Globals.entryTypesManager);
+            BibWriter bibWriter = new BibWriter(fileWriter, OS.NEWLINE);
+            BibDatabaseWriter databaseWriter = new BibtexDatabaseWriter(bibWriter, generalPreferences, savePreferences, Globals.entryTypesManager);
             databaseWriter.saveDatabase(new BibDatabaseContext(newBase));
 
             // Show just a warning message if encoding did not work for all characters:
diff --git a/src/main/java/org/jabref/gui/JabRefMain.java b/src/main/java/org/jabref/gui/JabRefMain.java
index 6b3090829c9..084356f5fe3 100644
--- a/src/main/java/org/jabref/gui/JabRefMain.java
+++ b/src/main/java/org/jabref/gui/JabRefMain.java
@@ -25,7 +25,6 @@
 import org.jabref.logic.protectedterms.ProtectedTermsLoader;
 import org.jabref.logic.remote.RemotePreferences;
 import org.jabref.logic.remote.client.RemoteClient;
-import org.jabref.logic.util.OS;
 import org.jabref.migrations.PreferencesMigrations;
 import org.jabref.model.database.BibDatabaseContext;
 import org.jabref.model.database.BibDatabaseMode;
@@ -141,10 +140,6 @@ private static void applyPreferences(PreferencesService preferences) {
 
         // Initialize protected terms loader
         Globals.protectedTermsLoader = new ProtectedTermsLoader(preferences.getProtectedTermsPreferences());
-
-        // Override used newline character with the one stored in the preferences.
-        // The preferences return the system newline character sequence as default.
-        OS.NEWLINE = preferences.getNewLineSeparator().toString();
     }
 
     private static void configureProxy(ProxyPreferences proxyPreferences) {
diff --git a/src/main/java/org/jabref/gui/SendAsEMailAction.java b/src/main/java/org/jabref/gui/SendAsEMailAction.java
index 7ea52d621f9..6ef1150cbe6 100644
--- a/src/main/java/org/jabref/gui/SendAsEMailAction.java
+++ b/src/main/java/org/jabref/gui/SendAsEMailAction.java
@@ -15,7 +15,9 @@
 import org.jabref.gui.util.BackgroundTask;
 import org.jabref.logic.bibtex.BibEntryWriter;
 import org.jabref.logic.bibtex.FieldWriter;
+import org.jabref.logic.exporter.BibWriter;
 import org.jabref.logic.l10n.Localization;
+import org.jabref.logic.util.OS;
 import org.jabref.logic.util.io.FileUtil;
 import org.jabref.model.database.BibDatabaseContext;
 import org.jabref.model.entry.BibEntry;
@@ -72,6 +74,7 @@ private String sendEmail() throws Exception {
         }
 
         StringWriter rawEntries = new StringWriter();
+        BibWriter bibWriter = new BibWriter(rawEntries, OS.NEWLINE);
         BibDatabaseContext databaseContext = stateManager.getActiveDatabase().get();
         List<BibEntry> entries = stateManager.getSelectedEntries();
 
@@ -80,7 +83,7 @@ private String sendEmail() throws Exception {
 
         for (BibEntry entry : entries) {
             try {
-                bibtexEntryWriter.write(entry, rawEntries, databaseContext.getMode());
+                bibtexEntryWriter.write(entry, bibWriter, databaseContext.getMode());
             } catch (IOException e) {
                 LOGGER.warn("Problem creating BibTeX file for mailing.", e);
             }
@@ -104,7 +107,7 @@ private String sendEmail() throws Exception {
             }
         }
 
-        String mailTo = "?Body=".concat(rawEntries.getBuffer().toString());
+        String mailTo = "?Body=".concat(rawEntries.toString());
         mailTo = mailTo.concat("&Subject=");
         mailTo = mailTo.concat(preferencesService.getExternalApplicationsPreferences().getEmailSubject());
         for (String path : attachments) {
diff --git a/src/main/java/org/jabref/gui/entryeditor/SourceTab.java b/src/main/java/org/jabref/gui/entryeditor/SourceTab.java
index 4f8e4d7fcc9..71b742190bf 100644
--- a/src/main/java/org/jabref/gui/entryeditor/SourceTab.java
+++ b/src/main/java/org/jabref/gui/entryeditor/SourceTab.java
@@ -38,11 +38,13 @@
 import org.jabref.logic.bibtex.FieldWriter;
 import org.jabref.logic.bibtex.FieldWriterPreferences;
 import org.jabref.logic.bibtex.InvalidFieldValueException;
+import org.jabref.logic.exporter.BibWriter;
 import org.jabref.logic.importer.ImportFormatPreferences;
 import org.jabref.logic.importer.ParserResult;
 import org.jabref.logic.importer.fileformat.BibtexParser;
 import org.jabref.logic.l10n.Localization;
 import org.jabref.logic.search.SearchQuery;
+import org.jabref.logic.util.OS;
 import org.jabref.model.database.BibDatabase;
 import org.jabref.model.database.BibDatabaseContext;
 import org.jabref.model.database.BibDatabaseMode;
@@ -128,11 +130,11 @@ private void highlightSearchPattern() {
     }
 
     private String getSourceString(BibEntry entry, BibDatabaseMode type, FieldWriterPreferences fieldWriterPreferences) throws IOException {
-        StringWriter stringWriter = new StringWriter(200);
+        StringWriter writer = new StringWriter();
+        BibWriter bibWriter = new BibWriter(writer, OS.NEWLINE);
         FieldWriter fieldWriter = FieldWriter.buildIgnoreHashes(fieldWriterPreferences);
-        new BibEntryWriter(fieldWriter, Globals.entryTypesManager).writeWithoutPrependedNewlines(entry, stringWriter, type);
-
-        return stringWriter.getBuffer().toString();
+        new BibEntryWriter(fieldWriter, Globals.entryTypesManager).write(entry, bibWriter, type);
+        return writer.toString();
     }
 
     /* Work around for different input methods.
diff --git a/src/main/java/org/jabref/gui/exporter/SaveDatabaseAction.java b/src/main/java/org/jabref/gui/exporter/SaveDatabaseAction.java
index a85f5acfd66..9757b885615 100644
--- a/src/main/java/org/jabref/gui/exporter/SaveDatabaseAction.java
+++ b/src/main/java/org/jabref/gui/exporter/SaveDatabaseAction.java
@@ -24,6 +24,7 @@
 import org.jabref.logic.autosaveandbackup.AutosaveManager;
 import org.jabref.logic.autosaveandbackup.BackupManager;
 import org.jabref.logic.exporter.AtomicFileWriter;
+import org.jabref.logic.exporter.BibWriter;
 import org.jabref.logic.exporter.BibtexDatabaseWriter;
 import org.jabref.logic.exporter.SaveException;
 import org.jabref.logic.exporter.SavePreferences;
@@ -229,12 +230,14 @@ private boolean saveDatabase(Path file, boolean selectedOnly, Charset encoding,
         SavePreferences savePreferences = this.preferences.getSavePreferences()
                                                       .withSaveType(saveType);
         try (AtomicFileWriter fileWriter = new AtomicFileWriter(file, encoding, savePreferences.shouldMakeBackup())) {
-            BibtexDatabaseWriter databaseWriter = new BibtexDatabaseWriter(fileWriter, generalPreferences, savePreferences, entryTypesManager);
+            BibDatabaseContext bibDatabaseContext = libraryTab.getBibDatabaseContext();
+            BibWriter bibWriter = new BibWriter(fileWriter, bibDatabaseContext.getDatabase().getNewLineSeparator());
+            BibtexDatabaseWriter databaseWriter = new BibtexDatabaseWriter(bibWriter, generalPreferences, savePreferences, entryTypesManager);
 
             if (selectedOnly) {
-                databaseWriter.savePartOfDatabase(libraryTab.getBibDatabaseContext(), libraryTab.getSelectedEntries());
+                databaseWriter.savePartOfDatabase(bibDatabaseContext, libraryTab.getSelectedEntries());
             } else {
-                databaseWriter.saveDatabase(libraryTab.getBibDatabaseContext());
+                databaseWriter.saveDatabase(bibDatabaseContext);
             }
 
             libraryTab.registerUndoableChanges(databaseWriter.getSaveActionsFieldChanges());
diff --git a/src/main/java/org/jabref/gui/preferences/file/FileTab.fxml b/src/main/java/org/jabref/gui/preferences/file/FileTab.fxml
index 742560fb2d3..8cc56872d65 100644
--- a/src/main/java/org/jabref/gui/preferences/file/FileTab.fxml
+++ b/src/main/java/org/jabref/gui/preferences/file/FileTab.fxml
@@ -31,10 +31,6 @@
                      toggleGroup="$stringsResolveToggleGroup"/>
         <TextField fx:id="resolveStringsExcept" HBox.hgrow="ALWAYS"/>
     </HBox>
-    <HBox alignment="CENTER_LEFT" spacing="10.0">
-        <Label alignment="TOP_LEFT" text="%Newline separator"/>
-        <ComboBox fx:id="newLineSeparator" prefWidth="120.0"/>
-    </HBox>
     <CheckBox fx:id="alwaysReformatBib" text="%Always reformat BIB file on save and export"/>
 
     <Label styleClass="sectionHeader" text="%Autosave"/>
diff --git a/src/main/java/org/jabref/gui/preferences/file/FileTab.java b/src/main/java/org/jabref/gui/preferences/file/FileTab.java
index c091c421f05..d6877b57c20 100644
--- a/src/main/java/org/jabref/gui/preferences/file/FileTab.java
+++ b/src/main/java/org/jabref/gui/preferences/file/FileTab.java
@@ -3,7 +3,6 @@
 import javafx.fxml.FXML;
 import javafx.scene.control.Button;
 import javafx.scene.control.CheckBox;
-import javafx.scene.control.ComboBox;
 import javafx.scene.control.RadioButton;
 import javafx.scene.control.TextField;
 
@@ -13,10 +12,8 @@
 import org.jabref.gui.help.HelpAction;
 import org.jabref.gui.preferences.AbstractPreferenceTabView;
 import org.jabref.gui.preferences.PreferencesTab;
-import org.jabref.gui.util.ViewModelListCellFactory;
 import org.jabref.logic.help.HelpFile;
 import org.jabref.logic.l10n.Localization;
-import org.jabref.preferences.NewLineSeparator;
 
 import com.airhacks.afterburner.views.ViewLoader;
 
@@ -27,7 +24,6 @@ public class FileTab extends AbstractPreferenceTabView<FileTabViewModel> impleme
     @FXML private RadioButton resolveStringsBibTex;
     @FXML private RadioButton resolveStringsAll;
     @FXML private TextField resolveStringsExcept;
-    @FXML private ComboBox<NewLineSeparator> newLineSeparator;
     @FXML private CheckBox alwaysReformatBib;
 
     @FXML private CheckBox autosaveLocalLibraries;
@@ -47,11 +43,6 @@ public void initialize() {
         resolveStringsAll.selectedProperty().bindBidirectional(viewModel.resolveStringsAllProperty());
         resolveStringsExcept.textProperty().bindBidirectional(viewModel.resolveStringsExceptProperty());
         resolveStringsExcept.disableProperty().bind(resolveStringsAll.selectedProperty().not());
-        new ViewModelListCellFactory<NewLineSeparator>()
-                .withText(NewLineSeparator::getDisplayName)
-                .install(newLineSeparator);
-        newLineSeparator.itemsProperty().bind(viewModel.newLineSeparatorListProperty());
-        newLineSeparator.valueProperty().bindBidirectional(viewModel.selectedNewLineSeparatorProperty());
         alwaysReformatBib.selectedProperty().bindBidirectional(viewModel.alwaysReformatBibProperty());
 
         autosaveLocalLibraries.selectedProperty().bindBidirectional(viewModel.autosaveLocalLibrariesProperty());
diff --git a/src/main/java/org/jabref/gui/preferences/file/FileTabViewModel.java b/src/main/java/org/jabref/gui/preferences/file/FileTabViewModel.java
index 09f7a10bc82..65a26ecf342 100644
--- a/src/main/java/org/jabref/gui/preferences/file/FileTabViewModel.java
+++ b/src/main/java/org/jabref/gui/preferences/file/FileTabViewModel.java
@@ -1,18 +1,12 @@
 package org.jabref.gui.preferences.file;
 
 import javafx.beans.property.BooleanProperty;
-import javafx.beans.property.ListProperty;
-import javafx.beans.property.ObjectProperty;
 import javafx.beans.property.SimpleBooleanProperty;
-import javafx.beans.property.SimpleListProperty;
-import javafx.beans.property.SimpleObjectProperty;
 import javafx.beans.property.SimpleStringProperty;
 import javafx.beans.property.StringProperty;
-import javafx.collections.FXCollections;
 
 import org.jabref.gui.preferences.PreferenceTabViewModel;
 import org.jabref.preferences.ImportExportPreferences;
-import org.jabref.preferences.NewLineSeparator;
 import org.jabref.preferences.PreferencesService;
 
 public class FileTabViewModel implements PreferenceTabViewModel {
@@ -22,8 +16,6 @@ public class FileTabViewModel implements PreferenceTabViewModel {
     private final BooleanProperty resolveStringsBibTexProperty = new SimpleBooleanProperty();
     private final BooleanProperty resolveStringsAllProperty = new SimpleBooleanProperty();
     private final StringProperty resolveStringsExceptProperty = new SimpleStringProperty("");
-    private final ListProperty<NewLineSeparator> newLineSeparatorListProperty = new SimpleListProperty<>();
-    private final ObjectProperty<NewLineSeparator> selectedNewLineSeparatorProperty = new SimpleObjectProperty<>();
     private final BooleanProperty alwaysReformatBibProperty = new SimpleBooleanProperty();
     private final BooleanProperty autosaveLocalLibraries = new SimpleBooleanProperty();
 
@@ -43,8 +35,6 @@ public void setValues() {
         resolveStringsAllProperty.setValue(importExportPreferences.shouldResolveStringsForAllStrings()); // Flipped around
         resolveStringsBibTexProperty.setValue(importExportPreferences.shouldResolveStringsForStandardBibtexFields());
         resolveStringsExceptProperty.setValue(importExportPreferences.getNonResolvableFields());
-        newLineSeparatorListProperty.setValue(FXCollections.observableArrayList(NewLineSeparator.values()));
-        selectedNewLineSeparatorProperty.setValue(importExportPreferences.getNewLineSeparator());
 
         alwaysReformatBibProperty.setValue(importExportPreferences.shouldAlwaysReformatOnSave());
 
@@ -59,7 +49,6 @@ public void storeSettings() {
         importExportPreferences.setResolveStringsForStandardBibtexFields(resolveStringsBibTexProperty.getValue());
         importExportPreferences.setResolveStringsForAllStrings(resolveStringsAllProperty.getValue());
         importExportPreferences.setNonResolvableFields(resolveStringsExceptProperty.getValue().trim());
-        importExportPreferences.setNewLineSeparator(selectedNewLineSeparatorProperty.getValue());
         importExportPreferences.setAlwaysReformatOnSave(alwaysReformatBibProperty.getValue());
 
         preferences.storeShouldAutosave(autosaveLocalLibraries.getValue());
@@ -89,14 +78,6 @@ public StringProperty resolveStringsExceptProperty() {
         return resolveStringsExceptProperty;
     }
 
-    public ListProperty<NewLineSeparator> newLineSeparatorListProperty() {
-        return newLineSeparatorListProperty;
-    }
-
-    public ObjectProperty<NewLineSeparator> selectedNewLineSeparatorProperty() {
-        return selectedNewLineSeparatorProperty;
-    }
-
     public BooleanProperty alwaysReformatBibProperty() {
         return alwaysReformatBibProperty;
     }
diff --git a/src/main/java/org/jabref/logic/autosaveandbackup/BackupManager.java b/src/main/java/org/jabref/logic/autosaveandbackup/BackupManager.java
index 0c063d26400..7ec9727a3af 100644
--- a/src/main/java/org/jabref/logic/autosaveandbackup/BackupManager.java
+++ b/src/main/java/org/jabref/logic/autosaveandbackup/BackupManager.java
@@ -1,6 +1,7 @@
 package org.jabref.logic.autosaveandbackup;
 
 import java.io.IOException;
+import java.io.Writer;
 import java.nio.charset.Charset;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -13,10 +14,12 @@
 
 import org.jabref.logic.bibtex.InvalidFieldValueException;
 import org.jabref.logic.exporter.AtomicFileWriter;
+import org.jabref.logic.exporter.BibWriter;
 import org.jabref.logic.exporter.BibtexDatabaseWriter;
 import org.jabref.logic.exporter.SavePreferences;
 import org.jabref.logic.util.CoarseChangeFilter;
 import org.jabref.logic.util.DelayTaskThrottler;
+import org.jabref.logic.util.OS;
 import org.jabref.logic.util.io.FileUtil;
 import org.jabref.model.database.BibDatabaseContext;
 import org.jabref.model.database.event.BibDatabaseContextChangedEvent;
@@ -135,7 +138,9 @@ private void performBackup(Path backupPath) {
             GeneralPreferences generalPreferences = preferences.getGeneralPreferences();
             SavePreferences savePreferences = preferences.getSavePreferences()
                                                          .withMakeBackup(false);
-            new BibtexDatabaseWriter(new AtomicFileWriter(backupPath, charset), generalPreferences, savePreferences, entryTypesManager)
+            Writer writer = new AtomicFileWriter(backupPath, charset);
+            BibWriter bibWriter = new BibWriter(writer, OS.NEWLINE);
+            new BibtexDatabaseWriter(bibWriter, generalPreferences, savePreferences, entryTypesManager)
                     .saveDatabase(bibDatabaseContext);
         } catch (IOException e) {
             logIfCritical(backupPath, e);
diff --git a/src/main/java/org/jabref/logic/bibtex/BibEntryWriter.java b/src/main/java/org/jabref/logic/bibtex/BibEntryWriter.java
index e5e24ef8278..ef93f2878cb 100644
--- a/src/main/java/org/jabref/logic/bibtex/BibEntryWriter.java
+++ b/src/main/java/org/jabref/logic/bibtex/BibEntryWriter.java
@@ -2,7 +2,6 @@
 
 import java.io.IOException;
 import java.io.StringWriter;
-import java.io.Writer;
 import java.util.Collection;
 import java.util.Comparator;
 import java.util.HashSet;
@@ -16,6 +15,7 @@
 import java.util.stream.Collectors;
 
 import org.jabref.logic.TypedBibEntry;
+import org.jabref.logic.exporter.BibWriter;
 import org.jabref.logic.util.OS;
 import org.jabref.model.database.BibDatabaseMode;
 import org.jabref.model.entry.BibEntry;
@@ -38,14 +38,14 @@ public BibEntryWriter(FieldWriter fieldWriter, BibEntryTypesManager entryTypesMa
 
     public String serializeAll(List<BibEntry> entries, BibDatabaseMode databaseMode) throws IOException {
         StringWriter writer = new StringWriter();
-
+        BibWriter bibWriter = new BibWriter(writer, OS.NEWLINE);
         for (BibEntry entry : entries) {
-            write(entry, writer, databaseMode);
+            write(entry, bibWriter, databaseMode);
         }
         return writer.toString();
     }
 
-    public void write(BibEntry entry, Writer out, BibDatabaseMode bibDatabaseMode) throws IOException {
+    public void write(BibEntry entry, BibWriter out, BibDatabaseMode bibDatabaseMode) throws IOException {
         write(entry, out, bibDatabaseMode, false);
     }
 
@@ -57,41 +57,33 @@ public void write(BibEntry entry, Writer out, BibDatabaseMode bibDatabaseMode) t
      * @param bibDatabaseMode The database mode (bibtex or biblatex)
      * @param reformat        Should the entry be in any case, even if no change occurred?
      */
-    public void write(BibEntry entry, Writer out, BibDatabaseMode bibDatabaseMode, Boolean reformat) throws IOException {
+    public void write(BibEntry entry, BibWriter out, BibDatabaseMode bibDatabaseMode, Boolean reformat) throws IOException {
         // if the entry has not been modified, write it as it was
         if (!reformat && !entry.hasChanged()) {
             out.write(entry.getParsedSerialization());
+            out.finishBlock();
             return;
         }
 
         writeUserComments(entry, out);
-        out.write(OS.NEWLINE);
         writeRequiredFieldsFirstRemainingFieldsSecond(entry, out, bibDatabaseMode);
-        out.write(OS.NEWLINE);
+        out.finishBlock();
     }
 
-    private void writeUserComments(BibEntry entry, Writer out) throws IOException {
+    private void writeUserComments(BibEntry entry, BibWriter out) throws IOException {
         String userComments = entry.getUserComments();
 
         if (!userComments.isEmpty()) {
-            out.write(userComments + OS.NEWLINE);
-        }
-    }
-
-    public void writeWithoutPrependedNewlines(BibEntry entry, Writer out, BibDatabaseMode bibDatabaseMode) throws IOException {
-        // if the entry has not been modified, write it as it was
-        if (!entry.hasChanged()) {
-            out.write(entry.getParsedSerialization().trim());
-            return;
+            out.write(userComments);
+            // ensure that a line break appears after the comment
+            out.finishLine();
         }
-
-        writeRequiredFieldsFirstRemainingFieldsSecond(entry, out, bibDatabaseMode);
     }
 
     /**
      * Writes fields in the order of requiredFields, optionalFields and other fields, but does not sort the fields.
      */
-    private void writeRequiredFieldsFirstRemainingFieldsSecond(BibEntry entry, Writer out,
+    private void writeRequiredFieldsFirstRemainingFieldsSecond(BibEntry entry, BibWriter out,
                                                                BibDatabaseMode bibDatabaseMode) throws IOException {
         // Write header with type and bibtex-key
         TypedBibEntry typedEntry = new TypedBibEntry(entry, bibDatabaseMode);
@@ -143,12 +135,12 @@ private void writeRequiredFieldsFirstRemainingFieldsSecond(BibEntry entry, Write
         }
 
         // Finally, end the entry.
-        out.write('}');
+        out.writeLine("}");
     }
 
-    private void writeKeyField(BibEntry entry, Writer out) throws IOException {
+    private void writeKeyField(BibEntry entry, BibWriter out) throws IOException {
         String keyField = StringUtil.shaveString(entry.getCitationKey().orElse(""));
-        out.write(keyField + ',' + OS.NEWLINE);
+        out.writeLine(keyField + ',');
     }
 
     /**
@@ -159,9 +151,9 @@ private void writeKeyField(BibEntry entry, Writer out) throws IOException {
      * @param field the field
      * @throws IOException In case of an IO error
      */
-    private void writeField(BibEntry entry, Writer out, Field field, int indentation) throws IOException {
+    private void writeField(BibEntry entry, BibWriter out, Field field, int indentation) throws IOException {
         Optional<String> value = entry.getField(field);
-        // only write field if is is not empty
+        // only write field if it is not empty
         // field.ifPresent does not work as an IOException may be thrown
         if (value.isPresent() && !value.get().trim().isEmpty()) {
             out.write("  " + getFormattedFieldName(field, indentation));
@@ -170,7 +162,7 @@ private void writeField(BibEntry entry, Writer out, Field field, int indentation
             } catch (InvalidFieldValueException ex) {
                 throw new IOException("Error in field '" + field + " of entry " + entry.getCitationKey().orElse("") + "': " + ex.getMessage(), ex);
             }
-            out.write(',' + OS.NEWLINE);
+            out.writeLine(",");
         }
     }
 
@@ -187,19 +179,17 @@ private int getLengthOfLongestFieldName(BibEntry entry) {
     /**
      * Get display version of a entry field.
      * <p>
-     * BibTeX is case-insensitive therefore there is no difference between:
-     * howpublished, HOWPUBLISHED, HowPublished, etc.
+     * BibTeX is case-insensitive therefore there is no difference between: howpublished, HOWPUBLISHED, HowPublished, etc.
      * <p>
-     * The was a long discussion about how JabRef should write the fields.
-     * See https://github.com/JabRef/jabref/issues/116
+     * There was a long discussion about how JabRef should write the fields. See https://github.com/JabRef/jabref/issues/116
      * <p>
      * The team decided to do the biblatex way and use lower case for the field names.
      *
      * @param field The name of the field.
      * @return The display version of the field name.
      */
-    private String getFormattedFieldName(Field field, int intendation) {
+    private String getFormattedFieldName(Field field, int intention) {
         String fieldName = field.getName();
-        return fieldName.toLowerCase(Locale.ROOT) + StringUtil.repeatSpaces(intendation - fieldName.length()) + " = ";
+        return fieldName.toLowerCase(Locale.ROOT) + StringUtil.repeatSpaces(intention - fieldName.length()) + " = ";
     }
 }
diff --git a/src/main/java/org/jabref/logic/cleanup/FieldFormatterCleanups.java b/src/main/java/org/jabref/logic/cleanup/FieldFormatterCleanups.java
index d480f5bfc9f..41e49fa0422 100644
--- a/src/main/java/org/jabref/logic/cleanup/FieldFormatterCleanups.java
+++ b/src/main/java/org/jabref/logic/cleanup/FieldFormatterCleanups.java
@@ -27,7 +27,7 @@ public FieldFormatterCleanups(boolean enabled, List<FieldFormatterCleanup> actio
         this.actions = Objects.requireNonNull(actions);
     }
 
-    private static String getMetaDataString(List<FieldFormatterCleanup> actionList, String newline) {
+    private static String getMetaDataString(List<FieldFormatterCleanup> actionList, String newLineSeparator) {
         // first, group all formatters by the field for which they apply
         Map<Field, List<String>> groupedByField = new TreeMap<>(Comparator.comparing(Field::getName));
         for (FieldFormatterCleanup cleanup : actionList) {
@@ -50,7 +50,7 @@ private static String getMetaDataString(List<FieldFormatterCleanup> actionList,
         for (Map.Entry<Field, List<String>> entry : groupedByField.entrySet()) {
             result.append(entry.getKey().getName());
 
-            StringJoiner joiner = new StringJoiner(",", "[", "]" + newline);
+            StringJoiner joiner = new StringJoiner(",", "[", "]" + newLineSeparator);
             entry.getValue().forEach(joiner::add);
             result.append(joiner.toString());
         }
diff --git a/src/main/java/org/jabref/logic/crawler/StudyRepository.java b/src/main/java/org/jabref/logic/crawler/StudyRepository.java
index f67a501042d..e876d94f0fa 100644
--- a/src/main/java/org/jabref/logic/crawler/StudyRepository.java
+++ b/src/main/java/org/jabref/logic/crawler/StudyRepository.java
@@ -15,7 +15,7 @@
 
 import org.jabref.logic.citationkeypattern.CitationKeyGenerator;
 import org.jabref.logic.database.DatabaseMerger;
-import org.jabref.logic.exporter.AtomicFileWriter;
+import org.jabref.logic.exporter.BibWriter;
 import org.jabref.logic.exporter.BibtexDatabaseWriter;
 import org.jabref.logic.exporter.SaveException;
 import org.jabref.logic.exporter.SavePreferences;
@@ -25,6 +25,7 @@
 import org.jabref.logic.importer.ParseException;
 import org.jabref.logic.importer.SearchBasedFetcher;
 import org.jabref.logic.l10n.Localization;
+import org.jabref.logic.util.OS;
 import org.jabref.model.database.BibDatabase;
 import org.jabref.model.database.BibDatabaseContext;
 import org.jabref.model.entry.BibEntryTypesManager;
@@ -416,11 +417,8 @@ private void writeResultToFile(Path pathToFile, BibDatabase entries) throws IOEx
             Files.createFile(pathToFile);
         }
         try (Writer fileWriter = new FileWriter(pathToFile.toFile())) {
-            BibtexDatabaseWriter databaseWriter = new BibtexDatabaseWriter(fileWriter, generalPreferences, savePreferences, bibEntryTypesManager);
-            databaseWriter.saveDatabase(new BibDatabaseContext(entries));
-        }
-        try (AtomicFileWriter fileWriter = new AtomicFileWriter(pathToFile, generalPreferences.getDefaultEncoding(), savePreferences.shouldMakeBackup())) {
-            BibtexDatabaseWriter databaseWriter = new BibtexDatabaseWriter(fileWriter, generalPreferences, savePreferences, bibEntryTypesManager);
+            BibWriter bibWriter = new BibWriter(fileWriter, OS.NEWLINE);
+            BibtexDatabaseWriter databaseWriter = new BibtexDatabaseWriter(bibWriter, generalPreferences, savePreferences, bibEntryTypesManager);
             databaseWriter.saveDatabase(new BibDatabaseContext(entries));
         } catch (UnsupportedCharsetException ex) {
             throw new SaveException(Localization.lang("Character encoding '%0' is not supported.", generalPreferences.getDefaultEncoding().displayName()), ex);
diff --git a/src/main/java/org/jabref/logic/exporter/BibDatabaseWriter.java b/src/main/java/org/jabref/logic/exporter/BibDatabaseWriter.java
index b8d91298e97..f62215b43ae 100644
--- a/src/main/java/org/jabref/logic/exporter/BibDatabaseWriter.java
+++ b/src/main/java/org/jabref/logic/exporter/BibDatabaseWriter.java
@@ -1,7 +1,6 @@
 package org.jabref.logic.exporter;
 
 import java.io.IOException;
-import java.io.Writer;
 import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -47,14 +46,14 @@
 public abstract class BibDatabaseWriter {
 
     private static final Pattern REFERENCE_PATTERN = Pattern.compile("(#[A-Za-z]+#)"); // Used to detect string references in strings
-    protected final Writer writer;
+    protected final BibWriter bibWriter;
     protected final GeneralPreferences generalPreferences;
     protected final SavePreferences savePreferences;
     protected final List<FieldChange> saveActionsFieldChanges = new ArrayList<>();
     protected final BibEntryTypesManager entryTypesManager;
 
-    public BibDatabaseWriter(Writer writer, GeneralPreferences generalPreferences, SavePreferences savePreferences, BibEntryTypesManager entryTypesManager) {
-        this.writer = Objects.requireNonNull(writer);
+    public BibDatabaseWriter(BibWriter bibWriter, GeneralPreferences generalPreferences, SavePreferences savePreferences, BibEntryTypesManager entryTypesManager) {
+        this.bibWriter = Objects.requireNonNull(bibWriter);
         this.generalPreferences = generalPreferences;
         this.savePreferences = savePreferences;
         this.entryTypesManager = entryTypesManager;
@@ -174,14 +173,13 @@ public void savePartOfDatabase(BibDatabaseContext bibDatabaseContext, List<BibEn
             writeDatabaseID(sharedDatabaseIDOptional.get());
         }
 
-        // Map to collect entry type definitions that we must save along with entries using them.
-        Set<BibEntryType> typesToWrite = new TreeSet<>();
-
         // Some file formats write something at the start of the file (like the encoding)
         if (savePreferences.getSaveType() != SavePreferences.DatabaseSaveType.PLAIN_BIBTEX) {
-            writePrelogue(bibDatabaseContext, generalPreferences.getDefaultEncoding());
+            writeProlog(bibDatabaseContext, generalPreferences.getDefaultEncoding());
         }
 
+        bibWriter.finishBlock();
+
         // Write preamble if there is one.
         writePreamble(bibDatabaseContext.getDatabase().getPreamble().orElse(""));
 
@@ -197,6 +195,9 @@ public void savePartOfDatabase(BibDatabaseContext bibDatabaseContext, List<BibEn
             saveActionsFieldChanges.addAll(keyChanges);
         }
 
+        // Map to collect entry type definitions that we must save along with entries using them.
+        Set<BibEntryType> typesToWrite = new TreeSet<>();
+
         for (BibEntry entry : sortedEntries) {
             // Check if we must write the type definition for this
             // entry, as well. Our criterion is that all non-standard
@@ -220,11 +221,9 @@ public void savePartOfDatabase(BibDatabaseContext bibDatabaseContext, List<BibEn
 
         // finally write whatever remains of the file, but at least a concluding newline
         writeEpilogue(bibDatabaseContext.getDatabase().getEpilog());
-
-        writer.close();
     }
 
-    protected abstract void writePrelogue(BibDatabaseContext bibDatabaseContext, Charset encoding) throws IOException;
+    protected abstract void writeProlog(BibDatabaseContext bibDatabaseContext, Charset encoding) throws IOException;
 
     protected abstract void writeEntry(BibEntry entry, BibDatabaseMode mode) throws IOException;
 
@@ -271,17 +270,17 @@ private void writeStrings(BibDatabase database) throws IOException {
         }
 
         for (BibtexString.Type t : BibtexString.Type.values()) {
-            boolean isFirstStringInType = true;
             for (BibtexString bs : strings) {
                 if (remaining.containsKey(bs.getName()) && (bs.getType() == t)) {
-                    writeString(bs, isFirstStringInType, remaining, maxKeyLength);
-                    isFirstStringInType = false;
+                    writeString(bs, remaining, maxKeyLength);
                 }
             }
         }
+
+        bibWriter.finishBlock();
     }
 
-    protected void writeString(BibtexString bibtexString, boolean isFirstString, Map<String, BibtexString> remaining, int maxKeyLength)
+    protected void writeString(BibtexString bibtexString, Map<String, BibtexString> remaining, int maxKeyLength)
             throws IOException {
         // First remove this from the "remaining" list so it can't cause problem with circular refs:
         remaining.remove(bibtexString.getName());
@@ -300,14 +299,14 @@ protected void writeString(BibtexString bibtexString, boolean isFirstString, Map
             // If the label we found exists as a key in the "remaining" Map, we go on and write it now:
             if (remaining.containsKey(label)) {
                 BibtexString referred = remaining.get(label);
-                writeString(referred, isFirstString, remaining, maxKeyLength);
+                writeString(referred, remaining, maxKeyLength);
             }
         }
 
-        writeString(bibtexString, isFirstString, maxKeyLength);
+        writeString(bibtexString, maxKeyLength);
     }
 
-    protected abstract void writeString(BibtexString bibtexString, boolean isFirstString, int maxKeyLength)
+    protected abstract void writeString(BibtexString bibtexString, int maxKeyLength)
             throws IOException;
 
     protected void writeEntryTypeDefinitions(Set<BibEntryType> types) throws IOException {
diff --git a/src/main/java/org/jabref/logic/exporter/BibWriter.java b/src/main/java/org/jabref/logic/exporter/BibWriter.java
new file mode 100644
index 00000000000..fd03941cf74
--- /dev/null
+++ b/src/main/java/org/jabref/logic/exporter/BibWriter.java
@@ -0,0 +1,72 @@
+package org.jabref.logic.exporter;
+
+import java.io.IOException;
+import java.io.Writer;
+
+import org.jabref.model.strings.StringUtil;
+
+/**
+ * Class to write to a .bib file. Used by {@link BibtexDatabaseWriter}
+ */
+public class BibWriter {
+
+    private final String newLineSeparator;
+    private final Writer writer;
+
+    private boolean precedingNewLineRequired = false;
+    private boolean somethingWasWritten = false;
+    private boolean lastWriteWasNewline = false;
+
+    /**
+     * @param newLineSeparator the string used for a line break
+     */
+    public BibWriter(Writer writer, String newLineSeparator) {
+        this.writer = writer;
+        this.newLineSeparator = newLineSeparator;
+    }
+
+    /**
+     * Writes the given string. The newlines of the given string are converted to the newline set for this clas
+     */
+    public void write(String string) throws IOException {
+        if (precedingNewLineRequired) {
+            writer.write(newLineSeparator);
+            precedingNewLineRequired = false;
+        }
+        string = StringUtil.unifyLineBreaks(string, newLineSeparator);
+        writer.write(string);
+        lastWriteWasNewline = string.endsWith(newLineSeparator);
+        somethingWasWritten = true;
+    }
+
+    /**
+     * Writes the given string and finishes it with a line break
+     */
+    public void writeLine(String string) throws IOException {
+        this.write(string);
+        this.finishLine();
+    }
+
+    /**
+     * Finishes a line
+     */
+    public void finishLine() throws IOException {
+        if (!this.lastWriteWasNewline) {
+            this.write(newLineSeparator);
+        }
+    }
+
+    /**
+     * Finishes a block
+     */
+    public void finishBlock() throws IOException {
+        if (!somethingWasWritten) {
+            return;
+        }
+        if (!lastWriteWasNewline) {
+            this.finishLine();
+        }
+        this.somethingWasWritten = false;
+        this.precedingNewLineRequired = true;
+    }
+}
diff --git a/src/main/java/org/jabref/logic/exporter/BibtexDatabaseWriter.java b/src/main/java/org/jabref/logic/exporter/BibtexDatabaseWriter.java
index 09a8c331ac5..84227448fe9 100644
--- a/src/main/java/org/jabref/logic/exporter/BibtexDatabaseWriter.java
+++ b/src/main/java/org/jabref/logic/exporter/BibtexDatabaseWriter.java
@@ -3,12 +3,12 @@
 import java.io.IOException;
 import java.io.Writer;
 import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.Map;
 
 import org.jabref.logic.bibtex.BibEntryWriter;
 import org.jabref.logic.bibtex.FieldWriter;
 import org.jabref.logic.bibtex.InvalidFieldValueException;
-import org.jabref.logic.util.OS;
 import org.jabref.model.database.BibDatabaseContext;
 import org.jabref.model.database.BibDatabaseMode;
 import org.jabref.model.entry.BibEntry;
@@ -27,110 +27,105 @@ public class BibtexDatabaseWriter extends BibDatabaseWriter {
     private static final String COMMENT_PREFIX = "@Comment";
     private static final String PREAMBLE_PREFIX = "@Preamble";
 
-    public BibtexDatabaseWriter(Writer writer, GeneralPreferences generalPreferences, SavePreferences savePreferences, BibEntryTypesManager entryTypesManager) {
-        super(writer, generalPreferences, savePreferences, entryTypesManager);
+    public BibtexDatabaseWriter(BibWriter bibWriter, GeneralPreferences generalPreferences, SavePreferences savePreferences, BibEntryTypesManager entryTypesManager) {
+        super(bibWriter, generalPreferences, savePreferences, entryTypesManager);
+    }
+
+    public BibtexDatabaseWriter(Writer writer, String newline, GeneralPreferences generalPreferences, SavePreferences savePreferences, BibEntryTypesManager entryTypesManager) {
+        super(new BibWriter(writer, newline), generalPreferences, savePreferences, entryTypesManager);
     }
 
     @Override
     protected void writeEpilogue(String epilogue) throws IOException {
         if (!StringUtil.isNullOrEmpty(epilogue)) {
-            writer.write(OS.NEWLINE);
-            writer.write(epilogue);
-            writer.write(OS.NEWLINE);
+            bibWriter.write(epilogue);
+            bibWriter.finishBlock();
         }
     }
 
     @Override
     protected void writeMetaDataItem(Map.Entry<String, String> metaItem) throws IOException {
-        writer.write(OS.NEWLINE);
-        writer.write(COMMENT_PREFIX + "{");
-        writer.write(MetaData.META_FLAG);
-        writer.write(metaItem.getKey());
-        writer.write(":");
-        writer.write(metaItem.getValue());
-        writer.write("}");
-        writer.write(OS.NEWLINE);
+        bibWriter.write(COMMENT_PREFIX + "{");
+        bibWriter.write(MetaData.META_FLAG);
+        bibWriter.write(metaItem.getKey());
+        bibWriter.write(":");
+        bibWriter.write(metaItem.getValue());
+        bibWriter.write("}");
+        bibWriter.finishBlock();
     }
 
     @Override
     protected void writePreamble(String preamble) throws IOException {
         if (!StringUtil.isNullOrEmpty(preamble)) {
-            writer.write(OS.NEWLINE);
-            writer.write(PREAMBLE_PREFIX + "{");
-            writer.write(preamble);
-            writer.write('}' + OS.NEWLINE);
+            bibWriter.write(PREAMBLE_PREFIX + "{");
+            bibWriter.write(preamble);
+            bibWriter.writeLine("}");
+            bibWriter.finishBlock();
         }
     }
 
     @Override
-    protected void writeString(BibtexString bibtexString, boolean isFirstString, int maxKeyLength) throws IOException {
+    protected void writeString(BibtexString bibtexString, int maxKeyLength) throws IOException {
         // If the string has not been modified, write it back as it was
         if (!savePreferences.shouldReformatFile() && !bibtexString.hasChanged()) {
-            writer.write(bibtexString.getParsedSerialization());
+            bibWriter.write(bibtexString.getParsedSerialization());
             return;
         }
 
         // Write user comments
         String userComments = bibtexString.getUserComments();
         if (!userComments.isEmpty()) {
-            writer.write(userComments + OS.NEWLINE);
-        }
-
-        if (isFirstString) {
-            writer.write(OS.NEWLINE);
+            bibWriter.writeLine(userComments);
         }
 
-        writer.write(STRING_PREFIX + "{" + bibtexString.getName() + StringUtil
+        bibWriter.write(STRING_PREFIX + "{" + bibtexString.getName() + StringUtil
                 .repeatSpaces(maxKeyLength - bibtexString.getName().length()) + " = ");
         if (bibtexString.getContent().isEmpty()) {
-            writer.write("{}");
+            bibWriter.write("{}");
         } else {
             try {
                 String formatted = new FieldWriter(savePreferences.getFieldWriterPreferences())
                         .write(InternalField.BIBTEX_STRING, bibtexString.getContent()
                         );
-                writer.write(formatted);
+                bibWriter.write(formatted);
             } catch (InvalidFieldValueException ex) {
                 throw new IOException(ex);
             }
         }
 
-        writer.write("}" + OS.NEWLINE);
+        bibWriter.writeLine("}");
     }
 
     @Override
     protected void writeEntryTypeDefinition(BibEntryType customType) throws IOException {
-        writer.write(OS.NEWLINE);
-        writer.write(COMMENT_PREFIX + "{");
-        writer.write(BibEntryTypesManager.serialize(customType));
-        writer.write("}");
-        writer.write(OS.NEWLINE);
+        bibWriter.write(COMMENT_PREFIX + "{");
+        bibWriter.write(BibEntryTypesManager.serialize(customType));
+        bibWriter.writeLine("}");
+        bibWriter.finishBlock();
     }
 
     @Override
-    protected void writePrelogue(BibDatabaseContext bibDatabaseContext, Charset encoding) throws IOException {
-        if (encoding == null) {
+    protected void writeProlog(BibDatabaseContext bibDatabaseContext, Charset encoding) throws IOException {
+        if ((encoding == null) || (encoding == StandardCharsets.UTF_8)) {
             return;
         }
 
         // Writes the file encoding information.
-        writer.write("% ");
-        writer.write(SavePreferences.ENCODING_PREFIX + encoding);
-        writer.write(OS.NEWLINE);
+        bibWriter.write("% ");
+        bibWriter.writeLine(SavePreferences.ENCODING_PREFIX + encoding);
     }
 
     @Override
     protected void writeDatabaseID(String sharedDatabaseID) throws IOException {
-        writer.write("% " +
-                DATABASE_ID_PREFIX +
-                " " +
-                sharedDatabaseID +
-                OS.NEWLINE);
+        bibWriter.write("% ");
+        bibWriter.write(DATABASE_ID_PREFIX);
+        bibWriter.write(" ");
+        bibWriter.writeLine(sharedDatabaseID);
     }
 
     @Override
     protected void writeEntry(BibEntry entry, BibDatabaseMode mode) throws IOException {
         BibEntryWriter bibtexEntryWriter = new BibEntryWriter(new FieldWriter(savePreferences.getFieldWriterPreferences()), entryTypesManager);
-        bibtexEntryWriter.write(entry, writer, mode, savePreferences.shouldReformatFile());
+        bibtexEntryWriter.write(entry, bibWriter, mode, savePreferences.shouldReformatFile());
     }
 }
diff --git a/src/main/java/org/jabref/logic/exporter/EmbeddedBibFilePdfExporter.java b/src/main/java/org/jabref/logic/exporter/EmbeddedBibFilePdfExporter.java
index e4735cfc2c2..ea8782474c9 100644
--- a/src/main/java/org/jabref/logic/exporter/EmbeddedBibFilePdfExporter.java
+++ b/src/main/java/org/jabref/logic/exporter/EmbeddedBibFilePdfExporter.java
@@ -15,6 +15,7 @@
 import org.jabref.logic.bibtex.BibEntryWriter;
 import org.jabref.logic.bibtex.FieldWriter;
 import org.jabref.logic.bibtex.FieldWriterPreferences;
+import org.jabref.logic.util.OS;
 import org.jabref.logic.util.StandardFileType;
 import org.jabref.logic.util.io.FileUtil;
 import org.jabref.model.database.BibDatabaseContext;
@@ -101,12 +102,13 @@ private void embedBibTex(String bibTeX, Path file, Charset encoding) throws IOEx
     }
 
     private String getBibString(List<BibEntry> entries) throws IOException {
-        StringWriter stringWriter = new StringWriter(200);
+        StringWriter stringWriter = new StringWriter();
+        BibWriter bibWriter = new BibWriter(stringWriter, OS.NEWLINE);
         FieldWriter fieldWriter = FieldWriter.buildIgnoreHashes(fieldWriterPreferences);
         BibEntryWriter bibEntryWriter = new BibEntryWriter(fieldWriter, bibEntryTypesManager);
         for (BibEntry entry : entries) {
-            bibEntryWriter.writeWithoutPrependedNewlines(entry, stringWriter, bibDatabaseMode);
+            bibEntryWriter.write(entry, bibWriter, bibDatabaseMode);
         }
-        return stringWriter.getBuffer().toString();
+        return stringWriter.toString();
     }
 }
diff --git a/src/main/java/org/jabref/logic/importer/fileformat/BibtexParser.java b/src/main/java/org/jabref/logic/importer/fileformat/BibtexParser.java
index eb348459668..c1f75f9dcba 100644
--- a/src/main/java/org/jabref/logic/importer/fileformat/BibtexParser.java
+++ b/src/main/java/org/jabref/logic/importer/fileformat/BibtexParser.java
@@ -6,6 +6,7 @@
 import java.io.InputStreamReader;
 import java.io.PushbackReader;
 import java.io.Reader;
+import java.io.StringWriter;
 import java.nio.charset.StandardCharsets;
 import java.util.Collection;
 import java.util.Deque;
@@ -29,6 +30,7 @@
 import org.jabref.logic.importer.ParserResult;
 import org.jabref.logic.importer.util.MetaDataParser;
 import org.jabref.logic.l10n.Localization;
+import org.jabref.logic.util.OS;
 import org.jabref.model.database.BibDatabase;
 import org.jabref.model.database.KeyCollisionException;
 import org.jabref.model.entry.BibEntry;
@@ -64,7 +66,7 @@
 public class BibtexParser implements Parser {
     private static final Logger LOGGER = LoggerFactory.getLogger(BibtexParser.class);
 
-    private static final Integer LOOKAHEAD = 64;
+    private static final Integer LOOKAHEAD = 1024;
     private final FieldContentFormatter fieldContentFormatter;
     private final Deque<Character> pureTextFromFile = new LinkedList<>();
     private final ImportFormatPreferences importFormatPreferences;
@@ -132,8 +134,10 @@ public ParserResult parse(Reader in) throws IOException {
         Objects.requireNonNull(in);
         pushbackReader = new PushbackReader(in, BibtexParser.LOOKAHEAD);
 
-        // Bibtex related contents.
-        initializeParserResult();
+        String newLineSeparator = determineNewLineSeparator();
+
+        // BibTeX related contents.
+        initializeParserResult(newLineSeparator);
 
         parseDatabaseID();
 
@@ -142,14 +146,36 @@ public ParserResult parse(Reader in) throws IOException {
         return parseFileContent();
     }
 
-    private void initializeParserResult() {
+    private String determineNewLineSeparator() throws IOException {
+        String newLineSeparator = OS.NEWLINE;
+        StringWriter stringWriter = new StringWriter(BibtexParser.LOOKAHEAD);
+        int i = 0;
+        int currentChar;
+        do {
+            currentChar = pushbackReader.read();
+            stringWriter.append((char) currentChar);
+            i++;
+        } while ((i < BibtexParser.LOOKAHEAD) && (currentChar != '\r') && (currentChar != '\n'));
+        if (currentChar == '\r') {
+            newLineSeparator = "\r\n";
+        } else if (currentChar == '\n') {
+            newLineSeparator = "\n";
+        }
+
+        // unread all sneaked characters
+        pushbackReader.unread(stringWriter.toString().toCharArray());
+
+        return newLineSeparator;
+    }
+
+    private void initializeParserResult(String newLineSeparator) {
         database = new BibDatabase();
+        database.setNewLineSeparator(newLineSeparator);
         entryTypes = new HashSet<>(); // To store custom entry types parsed.
         parserResult = new ParserResult(database, new MetaData(), entryTypes);
     }
 
     private void parseDatabaseID() throws IOException {
-
         while (!eof) {
             skipWhitespace();
             char c = (char) read();
@@ -185,7 +211,7 @@ private ParserResult parseFileContent() throws IOException {
 
             if ("preamble".equals(entryType)) {
                 database.setPreamble(parsePreamble());
-                // Consume new line which signals end of preamble
+                // Consume a new line which separates the preamble from the next part (if the file was written with JabRef)
                 skipOneNewline();
                 // the preamble is saved verbatim anyways, so the text read so far can be dropped
                 dumpTextReadSoFarToString();
@@ -233,12 +259,23 @@ private void parseAndAddEntry(String type) {
             // this is at least `@Type`
             String commentsAndEntryTypeDefinition = dumpTextReadSoFarToString();
 
+            // remove first newline
+            // this is appended by JabRef during writing automatically
+            if (commentsAndEntryTypeDefinition.startsWith("\r\n")) {
+                commentsAndEntryTypeDefinition = commentsAndEntryTypeDefinition.substring(2);
+            } else if (commentsAndEntryTypeDefinition.startsWith("\n")) {
+                commentsAndEntryTypeDefinition = commentsAndEntryTypeDefinition.substring(1);
+            }
+
             BibEntry entry = parseEntry(type);
             // store comments collected without type definition
             entry.setCommentsBeforeEntry(
                     commentsAndEntryTypeDefinition.substring(0, commentsAndEntryTypeDefinition.lastIndexOf('@')));
+
             // store complete parsed serialization (comments, type definition + type contents)
-            entry.setParsedSerialization(commentsAndEntryTypeDefinition + dumpTextReadSoFarToString());
+
+            String parsedSerialization = commentsAndEntryTypeDefinition + dumpTextReadSoFarToString();
+            entry.setParsedSerialization(parsedSerialization);
 
             database.insertEntry(entry);
         } catch (IOException ex) {
@@ -345,7 +382,13 @@ private String purge(String context, String stringToPurge) {
             }
             runningIndex++;
         }
-        return context.substring(runningIndex + 1);
+        // strip empty lines
+        while ((runningIndex < indexOfAt) &&
+                (context.charAt(runningIndex) == '\r' ||
+                        context.charAt(runningIndex) == '\n')) {
+            runningIndex++;
+        }
+        return context.substring(runningIndex);
     }
 
     private String getPureTextFromFile() {
@@ -500,7 +543,10 @@ private BibtexString parseString() throws IOException {
 
     private String parsePreamble() throws IOException {
         skipWhitespace();
-        return parseBracketedText();
+        String result = parseBracketedText();
+        // also "include" the newline in the preamble
+        skipOneNewline();
+        return result;
     }
 
     private BibEntry parseEntry(String entryType) throws IOException {
diff --git a/src/main/java/org/jabref/logic/util/OS.java b/src/main/java/org/jabref/logic/util/OS.java
index 2f97a16de20..d56a8a41363 100644
--- a/src/main/java/org/jabref/logic/util/OS.java
+++ b/src/main/java/org/jabref/logic/util/OS.java
@@ -6,12 +6,10 @@
  * Operating system (OS) detection
  */
 public class OS {
-    // File separator obtained from system
-    public static final String FILE_SEPARATOR = System.getProperty("file.separator");
+    public static final String NEWLINE = System.lineSeparator();
 
-    // Newlines
-    // will be overridden in initialization due to feature #857 @ JabRef.java
-    public static String NEWLINE = System.lineSeparator();
+    // File separator obtained from system
+    private static final String FILE_SEPARATOR = System.getProperty("file.separator");
 
     // https://commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/apache/commons/lang/SystemUtils.html
     private static final String OS_NAME = System.getProperty("os.name", "unknown").toLowerCase(Locale.ROOT);
diff --git a/src/main/java/org/jabref/model/database/BibDatabase.java b/src/main/java/org/jabref/model/database/BibDatabase.java
index 4349e371db9..1fdb22ee890 100644
--- a/src/main/java/org/jabref/model/database/BibDatabase.java
+++ b/src/main/java/org/jabref/model/database/BibDatabase.java
@@ -59,8 +59,16 @@ public class BibDatabase {
 
     // All file contents below the last entry in the file
     private String epilog = "";
+
     private String sharedDatabaseID;
 
+    private String newLineSeparator = System.lineSeparator();
+
+    public BibDatabase(List<BibEntry> entries, String newLineSeparator) {
+        this(entries);
+        this.newLineSeparator = newLineSeparator;
+    }
+
     public BibDatabase(List<BibEntry> entries) {
         this();
         insertEntries(entries);
@@ -622,4 +630,20 @@ public long getNumberOfCitationKeyOccurrences(String key) {
     public boolean isDuplicateCitationKeyExisting(String key) {
         return getNumberOfCitationKeyOccurrences(key) > 1;
     }
+
+    /**
+     * Set the newline separator.
+     * @param newLineSeparator
+     */
+    public void setNewLineSeparator(String newLineSeparator) {
+        this.newLineSeparator = newLineSeparator;
+    }
+
+    /**
+     * Returns the string used to indicate a linebreak
+     */
+    public String getNewLineSeparator() {
+        return newLineSeparator;
+    }
+
 }
diff --git a/src/main/java/org/jabref/model/entry/BibEntry.java b/src/main/java/org/jabref/model/entry/BibEntry.java
index e0311d8b615..28709bc1c52 100644
--- a/src/main/java/org/jabref/model/entry/BibEntry.java
+++ b/src/main/java/org/jabref/model/entry/BibEntry.java
@@ -12,7 +12,6 @@
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.BiFunction;
-import java.util.regex.Pattern;
 
 import javafx.beans.Observable;
 import javafx.beans.property.ObjectProperty;
@@ -57,7 +56,6 @@ public class BibEntry implements Cloneable {
 
     public static final EntryType DEFAULT_TYPE = StandardEntryType.Misc;
     private static final Logger LOGGER = LoggerFactory.getLogger(BibEntry.class);
-    private static final Pattern REMOVE_TRAILING_WHITESPACE = Pattern.compile("\\s+$");
     private final SharedBibEntryData sharedBibEntryData;
 
     /**
@@ -699,8 +697,7 @@ public void setParsedSerialization(String parsedSerialization) {
     }
 
     public void setCommentsBeforeEntry(String parsedComments) {
-        // delete trailing whitespaces (between entry and text)
-        this.commentsBeforeEntry = REMOVE_TRAILING_WHITESPACE.matcher(parsedComments).replaceFirst("");
+        this.commentsBeforeEntry = parsedComments;
     }
 
     public boolean hasChanged() {
diff --git a/src/main/java/org/jabref/model/entry/BibtexString.java b/src/main/java/org/jabref/model/entry/BibtexString.java
index 84e1518cf3e..6b7bd2c289b 100644
--- a/src/main/java/org/jabref/model/entry/BibtexString.java
+++ b/src/main/java/org/jabref/model/entry/BibtexString.java
@@ -145,22 +145,14 @@ public boolean hasChanged() {
      */
     public String getUserComments() {
         if (parsedSerialization != null) {
-
             try {
                 // get the text before the string
                 String prolog = parsedSerialization.substring(0, parsedSerialization.indexOf('@'));
-
-                // delete trailing whitespaces (between string and text)
-                prolog = prolog.replaceFirst("\\s+$", "");
-                // if there is any non whitespace text, write it with proper line separation
-                if (prolog.length() > 0) {
-                    return prolog;
-                }
+                return prolog;
             } catch (StringIndexOutOfBoundsException ignore) {
                 // if this occurs a broken parsed serialization has been set, so just do nothing
             }
         }
-
         return "";
     }
 
diff --git a/src/main/java/org/jabref/preferences/ImportExportPreferences.java b/src/main/java/org/jabref/preferences/ImportExportPreferences.java
index 51a465ecf0a..a8a8d8a4389 100644
--- a/src/main/java/org/jabref/preferences/ImportExportPreferences.java
+++ b/src/main/java/org/jabref/preferences/ImportExportPreferences.java
@@ -14,7 +14,6 @@ public class ImportExportPreferences {
     private final BooleanProperty resolveStringsForStandardBibtexFields;
     private final BooleanProperty resolveStringsForAllStrings;
     private final StringProperty nonResolvableFields;
-    private final ObjectProperty<NewLineSeparator> newLineSeparator;
     private final BooleanProperty alwaysReformatOnSave;
     private final ObjectProperty<Path> importWorkingDirectory;
     private final StringProperty lastExportExtension;
@@ -24,7 +23,6 @@ public ImportExportPreferences(String nonWrappableFields,
                                    boolean resolveStringsForStandardBibtexFields,
                                    boolean resolveStringsForAllStrings,
                                    String nonResolvableFields,
-                                   NewLineSeparator newLineSeparator,
                                    boolean alwaysReformatOnSave,
                                    Path importWorkingDirectory,
                                    String lastExportExtension,
@@ -33,7 +31,6 @@ public ImportExportPreferences(String nonWrappableFields,
         this.resolveStringsForStandardBibtexFields = new SimpleBooleanProperty(resolveStringsForStandardBibtexFields);
         this.resolveStringsForAllStrings = new SimpleBooleanProperty(resolveStringsForAllStrings);
         this.nonResolvableFields = new SimpleStringProperty(nonResolvableFields);
-        this.newLineSeparator = new SimpleObjectProperty<>(newLineSeparator);
         this.alwaysReformatOnSave = new SimpleBooleanProperty(alwaysReformatOnSave);
         this.importWorkingDirectory = new SimpleObjectProperty<>(importWorkingDirectory);
         this.lastExportExtension = new SimpleStringProperty(lastExportExtension);
@@ -88,18 +85,6 @@ public void setNonResolvableFields(String nonResolvableFields) {
         this.nonResolvableFields.set(nonResolvableFields);
     }
 
-    public NewLineSeparator getNewLineSeparator() {
-        return newLineSeparator.get();
-    }
-
-    public ObjectProperty<NewLineSeparator> newLineSeparatorProperty() {
-        return newLineSeparator;
-    }
-
-    public void setNewLineSeparator(NewLineSeparator newLineSeparator) {
-        this.newLineSeparator.set(newLineSeparator);
-    }
-
     public boolean shouldAlwaysReformatOnSave() {
         return alwaysReformatOnSave.get();
     }
diff --git a/src/main/java/org/jabref/preferences/JabRefPreferences.java b/src/main/java/org/jabref/preferences/JabRefPreferences.java
index ed4d4bf1b32..afda51c0f5c 100644
--- a/src/main/java/org/jabref/preferences/JabRefPreferences.java
+++ b/src/main/java/org/jabref/preferences/JabRefPreferences.java
@@ -2122,11 +2122,6 @@ public void storeOpenLastFilesOnStartup(boolean openLastFilesOnStartup) {
         putBoolean(OPEN_LAST_EDITED, openLastFilesOnStartup);
     }
 
-    @Override
-    public NewLineSeparator getNewLineSeparator() {
-        return NewLineSeparator.parse(get(NEWLINE));
-    }
-
     @Override
     public FieldContentFormatterPreferences getFieldContentParserPreferences() {
         return new FieldContentFormatterPreferences(
@@ -2259,7 +2254,6 @@ public ImportExportPreferences getImportExportPreferences() {
                 !getBoolean(RESOLVE_STRINGS_ALL_FIELDS),
                 getBoolean(RESOLVE_STRINGS_ALL_FIELDS),
                 get(DO_NOT_RESOLVE_STRINGS_FOR),
-                getNewLineSeparator(),
                 getBoolean(REFORMAT_FILE_ON_SAVE_AND_EXPORT),
                 Path.of(get(IMPORT_WORKING_DIRECTORY)),
                 get(LAST_USED_EXPORT),
@@ -2269,11 +2263,6 @@ public ImportExportPreferences getImportExportPreferences() {
         EasyBind.listen(importExportPreferences.resolveStringsForStandardBibtexFieldsProperty(), (obs, oldValue, newValue) -> putBoolean(RESOLVE_STRINGS_ALL_FIELDS, newValue));
         EasyBind.listen(importExportPreferences.resolveStringsForAllStringsProperty(), (obs, oldValue, newValue) -> putBoolean(RESOLVE_STRINGS_ALL_FIELDS, newValue));
         EasyBind.listen(importExportPreferences.nonResolvableFieldsProperty(), (obs, oldValue, newValue) -> put(DO_NOT_RESOLVE_STRINGS_FOR, newValue));
-        EasyBind.listen(importExportPreferences.newLineSeparatorProperty(), (obs, oldValue, newValue) -> {
-            String escapeChars = newValue.toString();
-            put(NEWLINE, escapeChars);
-            OS.NEWLINE = escapeChars;
-        });
         EasyBind.listen(importExportPreferences.alwaysReformatOnSaveProperty(), (obs, oldValue, newValue) -> putBoolean(REFORMAT_FILE_ON_SAVE_AND_EXPORT, newValue));
         EasyBind.listen(importExportPreferences.importWorkingDirectoryProperty(), (obs, oldValue, newValue) -> put(IMPORT_WORKING_DIRECTORY, newValue.toString()));
         EasyBind.listen(importExportPreferences.lastExportExtensionProperty(), (obs, oldValue, newValue) -> put(LAST_USED_EXPORT, newValue));
diff --git a/src/main/java/org/jabref/preferences/NewLineSeparator.java b/src/main/java/org/jabref/preferences/NewLineSeparator.java
deleted file mode 100644
index 6870cfc50b9..00000000000
--- a/src/main/java/org/jabref/preferences/NewLineSeparator.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package org.jabref.preferences;
-
-/**
- * An enum which contains the possible NewLineSeperators
- * Possible are CR ("\n"), LF ("\r") and the windows standard CR/LF.
- */
-public enum NewLineSeparator {
-    CR,
-    LF,
-    CRLF;
-
-    public String getDisplayName() {
-        switch (this) {
-            case CR:
-                return "CR (\"\\r\")";
-            case LF:
-                return "LF (\"\\n\")";
-            default:
-                return "CR/LF (\"\\r\\n\")";
-        }
-    }
-
-    /**
-     * @return the name of the current mode as String
-     */
-    public String toString() {
-        switch (this) {
-            case CR:
-                return "\r";
-            case LF:
-                return "\n";
-            default:
-                return "\r\n";
-        }
-    }
-
-    /**
-     * Returns the {@link NewLineSeparator} that equals the given string.
-     **/
-    public static NewLineSeparator parse(String data) {
-        switch (data) {
-            case "\r":
-                return CR;
-            case "\n":
-                return LF;
-            default:
-                return CRLF;
-        }
-    }
-}
-
diff --git a/src/main/java/org/jabref/preferences/PreferencesService.java b/src/main/java/org/jabref/preferences/PreferencesService.java
index fe7d74c0b5b..40448caba9a 100644
--- a/src/main/java/org/jabref/preferences/PreferencesService.java
+++ b/src/main/java/org/jabref/preferences/PreferencesService.java
@@ -238,8 +238,6 @@ public interface PreferencesService {
 
     void storeOpenLastFilesOnStartup(boolean openLastFilesOnStartup);
 
-    NewLineSeparator getNewLineSeparator();
-
     AutoLinkPreferences getAutoLinkPreferences();
 
     boolean shouldAutosave();
diff --git a/src/main/resources/l10n/JabRef_en.properties b/src/main/resources/l10n/JabRef_en.properties
index a27e30f60a7..fc36a885e39 100644
--- a/src/main/resources/l10n/JabRef_en.properties
+++ b/src/main/resources/l10n/JabRef_en.properties
@@ -1212,7 +1212,6 @@ Clear\ connection\ settings=Clear connection settings
 Open\ folder=Open folder
 Export\ sort\ order=Export sort order
 Save\ sort\ order=Save sort order
-Newline\ separator=Newline separator
 
 Keep\ original\ order=Keep original order
 Use\ current\ table\ sort\ order=Use current table sort order
diff --git a/src/test/java/org/jabref/logic/bibtex/BibEntryWriterTest.java b/src/test/java/org/jabref/logic/bibtex/BibEntryWriterTest.java
index 31a496a8a81..a1b1c0370c8 100644
--- a/src/test/java/org/jabref/logic/bibtex/BibEntryWriterTest.java
+++ b/src/test/java/org/jabref/logic/bibtex/BibEntryWriterTest.java
@@ -8,6 +8,7 @@
 import java.util.List;
 import java.util.Set;
 
+import org.jabref.logic.exporter.BibWriter;
 import org.jabref.logic.importer.ImportFormatPreferences;
 import org.jabref.logic.importer.ParserResult;
 import org.jabref.logic.importer.fileformat.BibtexParser;
@@ -35,20 +36,20 @@
 class BibEntryWriterTest {
 
     private static ImportFormatPreferences importFormatPreferences;
-    private BibEntryWriter writer;
+    private StringWriter stringWriter = new StringWriter();
+    private BibWriter bibWriter = new BibWriter(stringWriter, OS.NEWLINE);
+    private BibEntryWriter bibEntryWriter;
     private final FileUpdateMonitor fileMonitor = new DummyFileUpdateMonitor();
 
     @BeforeEach
     void setUpWriter() {
         importFormatPreferences = mock(ImportFormatPreferences.class, Answers.RETURNS_DEEP_STUBS);
         FieldWriterPreferences fieldWriterPreferences = mock(FieldWriterPreferences.class, Answers.RETURNS_DEEP_STUBS);
-        writer = new BibEntryWriter(new FieldWriter(fieldWriterPreferences), new BibEntryTypesManager());
+        bibEntryWriter = new BibEntryWriter(new FieldWriter(fieldWriterPreferences), new BibEntryTypesManager());
     }
 
     @Test
     void testSerialization() throws IOException {
-        StringWriter stringWriter = new StringWriter();
-
         BibEntry entry = new BibEntry(StandardEntryType.Article);
         // set a required field
         entry.setField(StandardField.AUTHOR, "Foo Bar");
@@ -57,12 +58,10 @@ void testSerialization() throws IOException {
         entry.setField(StandardField.NUMBER, "1");
         entry.setField(StandardField.NOTE, "some note");
 
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
-
-        String actual = stringWriter.toString();
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
 
         // @formatter:off
-        String expected = OS.NEWLINE + "@Article{," + OS.NEWLINE +
+        String expected = "@Article{," + OS.NEWLINE +
                 "  author  = {Foo Bar}," + OS.NEWLINE +
                 "  journal = {International Journal of Something}," + OS.NEWLINE +
                 "  note    = {some note}," + OS.NEWLINE +
@@ -70,12 +69,12 @@ void testSerialization() throws IOException {
                 "}" + OS.NEWLINE;
         // @formatter:on
 
-        assertEquals(expected, actual);
+        assertEquals(expected, stringWriter.toString());
     }
 
     @Test
     void writeOtherTypeTest() throws Exception {
-        String expected = OS.NEWLINE + "@Other{test," + OS.NEWLINE +
+        String expected = "@Other{test," + OS.NEWLINE +
                 "  comment = {testentry}," + OS.NEWLINE +
                 "}" + OS.NEWLINE;
 
@@ -83,12 +82,8 @@ void writeOtherTypeTest() throws Exception {
         entry.setField(StandardField.COMMENT, "testentry");
         entry.setCitationKey("test");
 
-        // write out bibtex string
-        StringWriter stringWriter = new StringWriter();
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
-        String actual = stringWriter.toString();
-
-        assertEquals(expected, actual);
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
+        assertEquals(expected, stringWriter.toString());
     }
 
     @Test
@@ -97,11 +92,9 @@ void writeEntryWithFile() throws Exception {
         LinkedFile file = new LinkedFile("test", Path.of("/home/uers/test.pdf"), "PDF");
         entry.addFile(file);
 
-        StringWriter stringWriter = new StringWriter();
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
 
-        assertEquals(OS.NEWLINE +
-                "@Article{,"
+        assertEquals("@Article{,"
                 + OS.NEWLINE
                 + "  file = {test:/home/uers/test.pdf:PDF},"
                 + OS.NEWLINE
@@ -110,8 +103,6 @@ void writeEntryWithFile() throws Exception {
 
     @Test
     void writeEntryWithOrField() throws Exception {
-        StringWriter stringWriter = new StringWriter();
-
         BibEntry entry = new BibEntry(StandardEntryType.InBook);
         // set an required OR field (author/editor)
         entry.setField(StandardField.EDITOR, "Foo Bar");
@@ -120,12 +111,10 @@ void writeEntryWithOrField() throws Exception {
         entry.setField(StandardField.NUMBER, "1");
         entry.setField(StandardField.NOTE, "some note");
 
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
-
-        String actual = stringWriter.toString();
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
 
         // @formatter:off
-        String expected = OS.NEWLINE + "@InBook{," + OS.NEWLINE +
+        String expected = "@InBook{," + OS.NEWLINE +
                 "  editor  = {Foo Bar}," + OS.NEWLINE +
                 "  note    = {some note}," + OS.NEWLINE +
                 "  number  = {1}," + OS.NEWLINE +
@@ -133,13 +122,11 @@ void writeEntryWithOrField() throws Exception {
                 "}" + OS.NEWLINE;
         // @formatter:on
 
-        assertEquals(expected, actual);
+        assertEquals(expected, stringWriter.toString());
     }
 
     @Test
     void writeEntryWithOrFieldBothFieldsPresent() throws Exception {
-        StringWriter stringWriter = new StringWriter();
-
         BibEntry entry = new BibEntry(StandardEntryType.InBook);
         // set an required OR field with both fields(author/editor)
         entry.setField(StandardField.AUTHOR, "Foo Thor");
@@ -149,12 +136,10 @@ void writeEntryWithOrFieldBothFieldsPresent() throws Exception {
         entry.setField(StandardField.NUMBER, "1");
         entry.setField(StandardField.NOTE, "some note");
 
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
-
-        String actual = stringWriter.toString();
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
 
         // @formatter:off
-        String expected = OS.NEWLINE + "@InBook{," + OS.NEWLINE +
+        String expected = "@InBook{," + OS.NEWLINE +
                 "  author  = {Foo Thor}," + OS.NEWLINE +
                 "  editor  = {Edi Bar}," + OS.NEWLINE +
                 "  note    = {some note}," + OS.NEWLINE +
@@ -163,12 +148,12 @@ void writeEntryWithOrFieldBothFieldsPresent() throws Exception {
                 "}" + OS.NEWLINE;
         // @formatter:on
 
-        assertEquals(expected, actual);
+        assertEquals(expected, stringWriter.toString());
     }
 
     @Test
     void writeReallyUnknownTypeTest() throws Exception {
-        String expected = OS.NEWLINE + "@Reallyunknowntype{test," + OS.NEWLINE +
+        String expected = "@Reallyunknowntype{test," + OS.NEWLINE +
                 "  comment = {testentry}," + OS.NEWLINE +
                 "}" + OS.NEWLINE;
 
@@ -176,13 +161,9 @@ void writeReallyUnknownTypeTest() throws Exception {
         entry.setType(new UnknownEntryType("ReallyUnknownType"));
         entry.setField(StandardField.COMMENT, "testentry");
         entry.setCitationKey("test");
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
 
-        // write out bibtex string
-        StringWriter stringWriter = new StringWriter();
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
-        String actual = stringWriter.toString();
-
-        assertEquals(expected, actual);
+        assertEquals(expected, stringWriter.toString());
     }
 
     @Test
@@ -193,7 +174,7 @@ void roundTripTest() throws IOException {
                 "  Journal                  = {International Journal of Something}," + OS.NEWLINE +
                 "  Note                     = {some note}," + OS.NEWLINE +
                 "  Number                   = {1}" + OS.NEWLINE +
-                "}";
+                "}" + OS.NEWLINE;
         // @formatter:on
 
         // read in bibtex string
@@ -202,11 +183,9 @@ void roundTripTest() throws IOException {
         BibEntry entry = entries.iterator().next();
 
         // write out bibtex string
-        StringWriter stringWriter = new StringWriter();
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
-        String actual = stringWriter.toString();
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
 
-        assertEquals(bibtexEntry, actual);
+        assertEquals(bibtexEntry, stringWriter.toString());
     }
 
     @Test
@@ -217,7 +196,7 @@ void roundTripWithPrependingNewlines() throws IOException {
                 "  Journal                  = {International Journal of Something}," + OS.NEWLINE +
                 "  Note                     = {some note}," + OS.NEWLINE +
                 "  Number                   = {1}" + OS.NEWLINE +
-                "}";
+                "}" + OS.NEWLINE;
         // @formatter:on
 
         // read in bibtex string
@@ -226,17 +205,63 @@ void roundTripWithPrependingNewlines() throws IOException {
         BibEntry entry = entries.iterator().next();
 
         // write out bibtex string
-        StringWriter stringWriter = new StringWriter();
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
-        String actual = stringWriter.toString();
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
 
-        assertEquals(bibtexEntry, actual);
+        assertEquals(bibtexEntry.substring(2), stringWriter.toString());
+    }
+
+    @Test
+    void roundTripWithKeepsCRLFLineBreakStyle() throws IOException {
+        // @formatter:off
+        String bibtexEntry = "@Article{test,\r\n" +
+                "  Author                   = {Foo Bar},\r\n" +
+                "  Journal                  = {International Journal of Something},\r\n" +
+                "  Note                     = {some note},\r\n" +
+                "  Number                   = {1}\r\n" +
+                "}\r\n";
+        // @formatter:on
+
+        // read in bibtex string
+        ParserResult result = new BibtexParser(importFormatPreferences, fileMonitor).parse(new StringReader(bibtexEntry));
+        Collection<BibEntry> entries = result.getDatabase().getEntries();
+        BibEntry entry = entries.iterator().next();
+
+        // write out bibtex string
+        // need to reconfigure writer to use "\r\n"
+        bibWriter = new BibWriter(stringWriter, "\r\n");
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
+
+        assertEquals(bibtexEntry, stringWriter.toString());
+    }
+
+    @Test
+    void roundTripWithKeepsLFLineBreakStyle() throws IOException {
+        // @formatter:off
+        String bibtexEntry = "@Article{test,\n" +
+                "  Author                   = {Foo Bar},\n" +
+                "  Journal                  = {International Journal of Something},\n" +
+                "  Note                     = {some note},\n" +
+                "  Number                   = {1}\n" +
+                "}\n";
+        // @formatter:on
+
+        // read in bibtex string
+        ParserResult result = new BibtexParser(importFormatPreferences, fileMonitor).parse(new StringReader(bibtexEntry));
+        Collection<BibEntry> entries = result.getDatabase().getEntries();
+        BibEntry entry = entries.iterator().next();
+
+        // write out bibtex string
+        // need to reconfigure writer to use "\n"
+        bibWriter = new BibWriter(stringWriter, "\n");
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
+
+        assertEquals(bibtexEntry, stringWriter.toString());
     }
 
     @Test
     void roundTripWithModification() throws IOException {
         // @formatter:off
-        String bibtexEntry = OS.NEWLINE + "@Article{test," + OS.NEWLINE +
+        String bibtexEntry = "@Article{test," + OS.NEWLINE +
                 "  Author                   = {Foo Bar}," + OS.NEWLINE +
                 "  Journal                  = {International Journal of Something}," + OS.NEWLINE +
                 "  Note                     = {some note}," + OS.NEWLINE +
@@ -253,19 +278,17 @@ void roundTripWithModification() throws IOException {
         entry.setField(StandardField.AUTHOR, "BlaBla");
 
         // write out bibtex string
-        StringWriter stringWriter = new StringWriter();
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
-        String actual = stringWriter.toString();
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
 
         // @formatter:off
-        String expected = OS.NEWLINE + "@Article{test," + OS.NEWLINE +
+        String expected = "@Article{test," + OS.NEWLINE +
                 "  author  = {BlaBla}," + OS.NEWLINE +
                 "  journal = {International Journal of Something}," + OS.NEWLINE +
                 "  note    = {some note}," + OS.NEWLINE +
                 "  number  = {1}," + OS.NEWLINE +
                 "}" + OS.NEWLINE;
         // @formatter:on
-        assertEquals(expected, actual);
+        assertEquals(expected, stringWriter.toString());
     }
 
     @Test
@@ -289,12 +312,10 @@ void roundTripWithCamelCasingInTheOriginalEntryAndResultInLowerCase() throws IOE
         entry.setField(StandardField.AUTHOR, "BlaBla");
 
         // write out bibtex string
-        StringWriter stringWriter = new StringWriter();
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
-        String actual = stringWriter.toString();
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
 
         // @formatter:off
-        String expected = OS.NEWLINE + "@Article{test," + OS.NEWLINE +
+        String expected = "@Article{test," + OS.NEWLINE +
                 "  author       = {BlaBla}," + OS.NEWLINE +
                 "  journal      = {International Journal of Something}," + OS.NEWLINE +
                 "  note         = {some note}," + OS.NEWLINE +
@@ -302,7 +323,7 @@ void roundTripWithCamelCasingInTheOriginalEntryAndResultInLowerCase() throws IOE
                 "  howpublished = {asdf}," + OS.NEWLINE +
                 "}" + OS.NEWLINE;
         // @formatter:on
-        assertEquals(expected, actual);
+        assertEquals(expected, stringWriter.toString());
     }
 
     @Test
@@ -326,12 +347,10 @@ void testEntryTypeChange() throws IOException {
         entry.setType(StandardEntryType.InProceedings);
 
         // write out bibtex string
-        StringWriter stringWriter = new StringWriter();
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
-        String actual = stringWriter.toString();
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
 
         // @formatter:off
-        String expectedNewEntry = OS.NEWLINE + "@InProceedings{test," + OS.NEWLINE +
+        String expectedNewEntry = "@InProceedings{test," + OS.NEWLINE +
                 "  author       = {BlaBla}," + OS.NEWLINE +
                 "  note         = {some note}," + OS.NEWLINE +
                 "  number       = {1}," + OS.NEWLINE +
@@ -339,7 +358,7 @@ void testEntryTypeChange() throws IOException {
                 "  journal      = {International Journal of Something}," + OS.NEWLINE +
                 "}" + OS.NEWLINE;
         // @formatter:on
-        assertEquals(expectedNewEntry, actual);
+        assertEquals(expectedNewEntry, stringWriter.toString());
     }
 
     @Test
@@ -359,12 +378,41 @@ void roundTripWithAppendedNewlines() throws IOException {
         BibEntry entry = entries.iterator().next();
 
         // write out bibtex string
-        StringWriter stringWriter = new StringWriter();
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
         String actual = stringWriter.toString();
 
-        // Only one appending newline is written by the writer, the rest by FileActions. So, these should be removed here.
-        assertEquals(bibtexEntry.substring(0, bibtexEntry.length() - 1), actual);
+        // Only one appending newline is written by the writer
+        // OS.NEWLINE is used, not the given one
+        assertEquals(bibtexEntry.substring(0, bibtexEntry.length() - 2) + OS.NEWLINE, actual);
+    }
+
+    @Test
+    void roundTripNormalizesNewLines() throws IOException {
+        // @formatter:off
+        String bibtexEntry = "@Article{test,\n" +
+                "  Author                   = {Foo Bar},\r\n" +
+                "  Journal                  = {International Journal of Something},\n" +
+                "  Number                   = {1},\n" +
+                "  Note                     = {some note}\r\n" +
+                "}\n\n";
+        // @formatter:on
+
+        // read in bibtex string
+        ParserResult result = new BibtexParser(importFormatPreferences, fileMonitor).parse(new StringReader(bibtexEntry));
+        Collection<BibEntry> entries = result.getDatabase().getEntries();
+        BibEntry entry = entries.iterator().next();
+
+        // write out bibtex string
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
+        String actual = stringWriter.toString();
+
+        String expected = "@Article{test," + OS.NEWLINE +
+                "  Author                   = {Foo Bar}," + OS.NEWLINE +
+                "  Journal                  = {International Journal of Something}," + OS.NEWLINE +
+                "  Number                   = {1}," + OS.NEWLINE +
+                "  Note                     = {some note}" + OS.NEWLINE +
+                "}" + OS.NEWLINE;
+        assertEquals(expected, actual);
     }
 
     @Test
@@ -375,7 +423,7 @@ void multipleWritesWithoutModification() throws IOException {
                 "  Journal                  = {International Journal of Something}," + OS.NEWLINE +
                 "  Note                     = {some note}," + OS.NEWLINE +
                 "  Number                   = {1}" + OS.NEWLINE +
-                "}";
+                "}" + OS.NEWLINE;
         // @formatter:on
 
         String result = testSingleWrite(bibtexEntry);
@@ -392,10 +440,11 @@ private String testSingleWrite(String bibtexEntry) throws IOException {
         BibEntry entry = entries.iterator().next();
 
         // write out bibtex string
-        StringWriter stringWriter = new StringWriter();
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
-        String actual = stringWriter.toString();
+        StringWriter writer = new StringWriter();
+        BibWriter bibWriter = new BibWriter(writer, OS.NEWLINE);
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
 
+        String actual = writer.toString();
         assertEquals(bibtexEntry, actual);
         return actual;
     }
@@ -407,7 +456,7 @@ void monthFieldSpecialSyntax() throws IOException {
                 "  Author                   = {Foo Bar}," + OS.NEWLINE +
                 "  Month                    = mar," + OS.NEWLINE +
                 "  Number                   = {1}" + OS.NEWLINE +
-                "}";
+                "}" + OS.NEWLINE;
         // @formatter:on
 
         // read in bibtex string
@@ -421,11 +470,9 @@ void monthFieldSpecialSyntax() throws IOException {
         assertEquals("#mar#", entry.getField(StandardField.MONTH).get());
 
         // write out bibtex string
-        StringWriter stringWriter = new StringWriter();
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
-        String actual = stringWriter.toString();
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
 
-        assertEquals(bibtexEntry, actual);
+        assertEquals(bibtexEntry, stringWriter.toString());
     }
 
     @Test
@@ -435,11 +482,9 @@ void constantMonthApril() throws Exception {
         // enable writing
         entry.setChanged(true);
 
-        StringWriter stringWriter = new StringWriter();
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
 
-        assertEquals(OS.NEWLINE +
-                        "@Misc{," + OS.NEWLINE +
+        assertEquals("@Misc{," + OS.NEWLINE +
                         "  month = apr," + OS.NEWLINE +
                         "}" + OS.NEWLINE,
                 stringWriter.toString());
@@ -452,11 +497,9 @@ void monthApril() throws Exception {
         // enable writing
         entry.setChanged(true);
 
-        StringWriter stringWriter = new StringWriter();
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
 
-        assertEquals(OS.NEWLINE +
-                        "@Misc{," + OS.NEWLINE +
+        assertEquals("@Misc{," + OS.NEWLINE +
                         "  month = {apr}," + OS.NEWLINE +
                         "}" + OS.NEWLINE,
                 stringWriter.toString());
@@ -482,9 +525,7 @@ void addFieldWithLongerLength() throws IOException {
         entry.setField(StandardField.HOWPUBLISHED, "asdf");
 
         // write out bibtex string
-        StringWriter stringWriter = new StringWriter();
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
-        String actual = stringWriter.toString();
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
 
         // @formatter:off
         String expected = OS.NEWLINE + "@Article{test," + OS.NEWLINE +
@@ -495,36 +536,30 @@ void addFieldWithLongerLength() throws IOException {
                 "  howpublished = {asdf}," + OS.NEWLINE +
                 "}" + OS.NEWLINE;
         // @formatter:on
-        assertEquals(expected, actual);
+        assertEquals(expected, stringWriter.toString());
     }
 
     @Test
     void doNotWriteEmptyFields() throws IOException {
-        StringWriter stringWriter = new StringWriter();
-
         BibEntry entry = new BibEntry(StandardEntryType.Article);
         entry.setField(StandardField.AUTHOR, "  ");
         entry.setField(StandardField.NOTE, "some note");
 
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
-
-        String actual = stringWriter.toString();
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
 
-        String expected = OS.NEWLINE + "@Article{," + OS.NEWLINE +
+        String expected = "@Article{," + OS.NEWLINE +
                 "  note   = {some note}," + OS.NEWLINE +
                 "}" + OS.NEWLINE;
 
-        assertEquals(expected, actual);
+        assertEquals(expected, stringWriter.toString());
     }
 
     @Test
     void writeThrowsErrorIfFieldContainsUnbalancedBraces() {
-        StringWriter stringWriter = new StringWriter();
-
         BibEntry entry = new BibEntry(StandardEntryType.Article);
         entry.setField(StandardField.NOTE, "some text with unbalanced { braces");
 
-        assertThrows(IOException.class, () -> writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX));
+        assertThrows(IOException.class, () -> bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX));
     }
 
     @Test
@@ -536,7 +571,7 @@ void roundTripWithPrecedingCommentTest() throws IOException {
                 "  Journal                  = {International Journal of Something}," + OS.NEWLINE +
                 "  Note                     = {some note}," + OS.NEWLINE +
                 "  Number                   = {1}" + OS.NEWLINE +
-                "}";
+                "}" + OS.NEWLINE;
         // @formatter:on
 
         // read in bibtex string
@@ -545,11 +580,9 @@ void roundTripWithPrecedingCommentTest() throws IOException {
         BibEntry entry = entries.iterator().next();
 
         // write out bibtex string
-        StringWriter stringWriter = new StringWriter();
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
-        String actual = stringWriter.toString();
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
 
-        assertEquals(bibtexEntry, actual);
+        assertEquals(bibtexEntry, stringWriter.toString());
     }
 
     @Test
@@ -573,11 +606,10 @@ void roundTripWithPrecedingCommentAndModificationTest() throws IOException {
         entry.setField(StandardField.AUTHOR, "John Doe");
 
         // write out bibtex string
-        StringWriter stringWriter = new StringWriter();
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
-        String actual = stringWriter.toString();
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBTEX);
+
         // @formatter:off
-        String expected = "% Some random comment that should stay here" + OS.NEWLINE + OS.NEWLINE +
+        String expected = "% Some random comment that should stay here" + OS.NEWLINE +
                 "@Article{test," + OS.NEWLINE +
                 "  author  = {John Doe}," + OS.NEWLINE +
                 "  journal = {International Journal of Something}," + OS.NEWLINE +
@@ -586,13 +618,11 @@ void roundTripWithPrecedingCommentAndModificationTest() throws IOException {
                 "}" + OS.NEWLINE;
         // @formatter:on
 
-        assertEquals(expected, actual);
+        assertEquals(expected, stringWriter.toString());
     }
 
     @Test
     void alphabeticSerialization() throws IOException {
-        StringWriter stringWriter = new StringWriter();
-
         BibEntry entry = new BibEntry(StandardEntryType.Article);
         // required fields
         entry.setField(StandardField.AUTHOR, "Foo Bar");
@@ -606,12 +636,10 @@ void alphabeticSerialization() throws IOException {
         entry.setField(StandardField.YEAR, "2019");
         entry.setField(StandardField.CHAPTER, "chapter");
 
-        writer.write(entry, stringWriter, BibDatabaseMode.BIBLATEX);
-
-        String actual = stringWriter.toString();
+        bibEntryWriter.write(entry, bibWriter, BibDatabaseMode.BIBLATEX);
 
         // @formatter:off
-        String expected = OS.NEWLINE + "@Article{," + OS.NEWLINE +
+        String expected = "@Article{," + OS.NEWLINE +
                 "  author       = {Foo Bar}," + OS.NEWLINE +
                 "  date         = {2019-10-16}," + OS.NEWLINE +
                 "  journaltitle = {International Journal of Something}," + OS.NEWLINE +
@@ -623,7 +651,7 @@ void alphabeticSerialization() throws IOException {
                 "}" + OS.NEWLINE;
         // @formatter:on
 
-        assertEquals(expected, actual);
+        assertEquals(expected, stringWriter.toString());
     }
 
     @Test
@@ -656,10 +684,10 @@ void testSerializeAll() throws IOException {
         entry2.setField(StandardField.YEAR, "2020");
         entry2.setField(StandardField.CHAPTER, "chapter");
 
-        String output = writer.serializeAll(List.of(entry1, entry2), BibDatabaseMode.BIBLATEX);
+        String output = bibEntryWriter.serializeAll(List.of(entry1, entry2), BibDatabaseMode.BIBLATEX);
 
         // @formatter:off
-        String expected1 = OS.NEWLINE + "@Article{," + OS.NEWLINE +
+        String expected1 = "@Article{," + OS.NEWLINE +
                 "  author       = {Journal Author}," + OS.NEWLINE +
                 "  date         = {2020-11-16}," + OS.NEWLINE +
                 "  journaltitle = {Journal of Words}," + OS.NEWLINE +
@@ -672,7 +700,7 @@ void testSerializeAll() throws IOException {
         // @formatter:on
 
         // @formatter:off
-        String expected2 = OS.NEWLINE + "@Book{," + OS.NEWLINE +
+        String expected2 = "@Book{," + OS.NEWLINE +
                 "  author    = {John Book}," + OS.NEWLINE +
                 "  date      = {2017-12-20}," + OS.NEWLINE +
                 "  title     = {Entry Title}," + OS.NEWLINE +
@@ -684,7 +712,7 @@ void testSerializeAll() throws IOException {
                 "}" + OS.NEWLINE;
         // @formatter:on
 
-        assertEquals(expected1 + expected2, output);
+        assertEquals(expected1 + OS.NEWLINE + expected2, output);
 
     }
 }
diff --git a/src/test/java/org/jabref/logic/exporter/BibtexDatabaseWriterTest.java b/src/test/java/org/jabref/logic/exporter/BibtexDatabaseWriterTest.java
index a48da10a0e7..33713059eb4 100644
--- a/src/test/java/org/jabref/logic/exporter/BibtexDatabaseWriterTest.java
+++ b/src/test/java/org/jabref/logic/exporter/BibtexDatabaseWriterTest.java
@@ -60,7 +60,6 @@
 
 class BibtexDatabaseWriterTest {
 
-    private StringWriter stringWriter;
     private BibtexDatabaseWriter databaseWriter;
     private BibDatabase database;
     private MetaData metaData;
@@ -70,17 +69,20 @@ class BibtexDatabaseWriterTest {
     private GeneralPreferences generalPreferences;
     private SavePreferences savePreferences;
     private BibEntryTypesManager entryTypesManager;
+    private StringWriter stringWriter;
+    private BibWriter bibWriter;
 
     @BeforeEach
     void setUp() {
-        stringWriter = new StringWriter();
         generalPreferences = mock(GeneralPreferences.class);
         when(generalPreferences.getDefaultEncoding()).thenReturn(null);
         savePreferences = mock(SavePreferences.class, Answers.RETURNS_DEEP_STUBS);
         when(savePreferences.getSaveOrder()).thenReturn(new SaveOrderConfig());
         when(savePreferences.takeMetadataSaveOrderInAccount()).thenReturn(true);
         entryTypesManager = new BibEntryTypesManager();
-        databaseWriter = new BibtexDatabaseWriter(stringWriter, generalPreferences, savePreferences, entryTypesManager);
+        stringWriter = new StringWriter();
+        bibWriter = new BibWriter(stringWriter, OS.NEWLINE);
+        databaseWriter = new BibtexDatabaseWriter(bibWriter, generalPreferences, savePreferences, entryTypesManager);
 
         database = new BibDatabase();
         metaData = new MetaData();
@@ -113,7 +115,7 @@ void writePreamble() throws Exception {
 
         databaseWriter.savePartOfDatabase(bibtexContext, Collections.emptyList());
 
-        assertEquals(OS.NEWLINE + "@Preamble{Test preamble}" + OS.NEWLINE, stringWriter.toString());
+        assertEquals("@Preamble{Test preamble}" + OS.NEWLINE, stringWriter.toString());
     }
 
     @Test
@@ -135,9 +137,7 @@ void writeEntry() throws Exception {
 
         databaseWriter.savePartOfDatabase(bibtexContext, Collections.singletonList(entry));
 
-        assertEquals(
-                OS.NEWLINE +
-                        "@Article{," + OS.NEWLINE + "}"
+        assertEquals("@Article{," + OS.NEWLINE + "}"
                         + OS.NEWLINE,
                 stringWriter.toString());
     }
@@ -164,7 +164,7 @@ void writeEpilogue() throws Exception {
 
         databaseWriter.savePartOfDatabase(bibtexContext, Collections.emptyList());
 
-        assertEquals(OS.NEWLINE + "Test epilog" + OS.NEWLINE, stringWriter.toString());
+        assertEquals("Test epilog" + OS.NEWLINE, stringWriter.toString());
     }
 
     @Test
@@ -186,7 +186,7 @@ void writeMetadata() throws Exception {
 
         databaseWriter.savePartOfDatabase(bibtexContext, Collections.emptyList());
 
-        assertEquals(OS.NEWLINE + "@Comment{jabref-meta: keypatterndefault:test;}" + OS.NEWLINE,
+        assertEquals("@Comment{jabref-meta: keypatterndefault:test;}" + OS.NEWLINE,
                 stringWriter.toString());
     }
 
@@ -213,8 +213,7 @@ void writeGroups() throws Exception {
         databaseWriter.savePartOfDatabase(bibtexContext, Collections.emptyList());
 
         // @formatter:off
-        assertEquals(OS.NEWLINE
-                + "@Comment{jabref-meta: grouping:" + OS.NEWLINE
+        assertEquals("@Comment{jabref-meta: grouping:" + OS.NEWLINE
                 + "0 AllEntriesGroup:;" + OS.NEWLINE
                 + "1 StaticGroup:test\\;2\\;1\\;\\;\\;\\;;" + OS.NEWLINE
                 + "}" + OS.NEWLINE, stringWriter.toString());
@@ -248,7 +247,7 @@ void writeString() throws Exception {
 
         databaseWriter.savePartOfDatabase(bibtexContext, Collections.emptyList());
 
-        assertEquals(OS.NEWLINE + "@String{name = {content}}" + OS.NEWLINE, stringWriter.toString());
+        assertEquals("@String{name = {content}}" + OS.NEWLINE, stringWriter.toString());
     }
 
     @Test
@@ -262,6 +261,16 @@ void writeStringAndEncoding() throws Exception {
                 "@String{name = {content}}" + OS.NEWLINE, stringWriter.toString());
     }
 
+    @Test
+    void doNotWriteUtf8StringAndEncoding() throws Exception {
+        when(generalPreferences.getDefaultEncoding()).thenReturn(StandardCharsets.UTF_8);
+        database.addString(new BibtexString("name", "content"));
+
+        databaseWriter.savePartOfDatabase(bibtexContext, Collections.emptyList());
+
+        assertEquals("@String{name = {content}}" + OS.NEWLINE, stringWriter.toString());
+    }
+
     @Test
     void writeEntryWithCustomizedTypeAlsoWritesTypeDeclaration() throws Exception {
         EntryType customizedType = new UnknownEntryType("customizedType");
@@ -285,9 +294,7 @@ void writeEntryWithCustomizedTypeAlsoWritesTypeDeclaration() throws Exception {
 
         databaseWriter.saveDatabase(bibtexContext);
 
-        assertEquals(
-                OS.NEWLINE +
-                        "@Customizedtype{," + OS.NEWLINE + "}" + OS.NEWLINE + OS.NEWLINE
+        assertEquals("@Customizedtype{," + OS.NEWLINE + "}" + OS.NEWLINE + OS.NEWLINE
                         + "@Comment{jabref-meta: databaseType:bibtex;}"
                         + OS.NEWLINE + OS.NEWLINE
                         + "@Comment{jabref-entrytype: customizedtype: req[title;author;date] opt[year;month;publisher]}" + OS.NEWLINE,
@@ -317,8 +324,7 @@ void writeCustomizedTypesInAlphabeticalOrder() throws Exception {
         databaseWriter.savePartOfDatabase(bibtexContext, Arrays.asList(entry, otherEntry));
 
         assertEquals(
-                OS.NEWLINE
-                        + "@Customizedtype{," + OS.NEWLINE + "}" + OS.NEWLINE + OS.NEWLINE
+                "@Customizedtype{," + OS.NEWLINE + "}" + OS.NEWLINE + OS.NEWLINE
                         + "@Othercustomizedtype{," + OS.NEWLINE + "}" + OS.NEWLINE + OS.NEWLINE
                         + "@Comment{jabref-meta: databaseType:bibtex;}"
                         + OS.NEWLINE + OS.NEWLINE
@@ -341,6 +347,33 @@ void roundtripWithArticleMonths() throws Exception {
         assertEquals(Files.readString(testBibtexFile, encoding), stringWriter.toString());
     }
 
+    @Test
+    void roundtripUtf8EncodingHeaderRemoved() throws Exception {
+        when(generalPreferences.getDefaultEncoding()).thenReturn(StandardCharsets.UTF_8);
+        // @formatter:off
+        String bibtexEntry = OS.NEWLINE + "% Encoding: UTF8" + OS.NEWLINE +
+                OS.NEWLINE +
+                "@Article{," + OS.NEWLINE +
+                "  author  = {Foo Bar}," + OS.NEWLINE +
+                "  journal = {International Journal of Something}," + OS.NEWLINE +
+                "  note    = {some note}," + OS.NEWLINE +
+                "  number  = {1}," + OS.NEWLINE +
+                "}" + OS.NEWLINE;
+        // @formatter:on
+        ParserResult result = new BibtexParser(importFormatPreferences, fileMonitor).parse(new StringReader(bibtexEntry));
+        BibDatabaseContext context = new BibDatabaseContext(result.getDatabase(), result.getMetaData());
+        databaseWriter.saveDatabase(context);
+        // @formatter:off
+        String expected = "@Article{," + OS.NEWLINE +
+                "  author  = {Foo Bar}," + OS.NEWLINE +
+                "  journal = {International Journal of Something}," + OS.NEWLINE +
+                "  note    = {some note}," + OS.NEWLINE +
+                "  number  = {1}," + OS.NEWLINE +
+                "}" + OS.NEWLINE;
+        // @formatter:on
+       assertEquals(expected, stringWriter.toString());
+    }
+
     @Test
     void roundtripWithComplexBib() throws Exception {
         Path testBibtexFile = Path.of("src/test/resources/testbib/complex.bib");
@@ -369,6 +402,64 @@ void roundtripWithUserComment() throws Exception {
         assertEquals(Files.readString(testBibtexFile, encoding), stringWriter.toString());
     }
 
+    @Test
+    void roundtripWithOneUserCommentAndEntryChange() throws Exception {
+        String bibEntry = "@Comment this in an unbracketed comment that should be preserved as well\n" +
+                "\n" +
+                "This is some arbitrary user comment that should be preserved\n" +
+                "\n" +
+                "@InProceedings{1137631,\n" +
+                "  author     = {Mr. Author},\n" +
+                "}\n";
+
+        // read in bibtex string
+        ImportFormatPreferences importFormatPreferences = mock(ImportFormatPreferences.class, Answers.RETURNS_DEEP_STUBS);
+        ParserResult result = new BibtexParser(importFormatPreferences, new DummyFileUpdateMonitor()).parse(new StringReader(bibEntry));
+
+        BibEntry entry = result.getDatabase().getEntryByCitationKey("1137631").get();
+        entry.setField(StandardField.AUTHOR, "Mr. Author");
+
+        when(generalPreferences.getDefaultEncoding()).thenReturn(StandardCharsets.UTF_8);
+        when(savePreferences.shouldSaveInOriginalOrder()).thenReturn(true);
+        BibDatabaseContext context = new BibDatabaseContext(result.getDatabase(), result.getMetaData());
+
+        // we need a new writer because "\n" instead of "OS.NEWLINE"
+        bibWriter = new BibWriter(stringWriter, "\n");
+        databaseWriter = new BibtexDatabaseWriter(bibWriter, generalPreferences, savePreferences, entryTypesManager);
+        databaseWriter.savePartOfDatabase(context, result.getDatabase().getEntries());
+        assertEquals(bibEntry, stringWriter.toString());
+    }
+
+    @Test
+    void roundtripWithTwoEntriesAndOneUserCommentAndEntryChange() throws Exception {
+        String bibEntry = "@Article{test,}\n" +
+                "\n" +
+                "@Comment this in an unbracketed comment that should be preserved as well\n" +
+                "\n" +
+                "This is some arbitrary user comment that should be preserved\n" +
+                "\n" +
+                "@InProceedings{1137631,\n" +
+                "  author     = {Mr. Author},\n" +
+                "}\n";
+
+        // read in bibtex string
+        ImportFormatPreferences importFormatPreferences = mock(ImportFormatPreferences.class, Answers.RETURNS_DEEP_STUBS);
+        ParserResult result = new BibtexParser(importFormatPreferences, new DummyFileUpdateMonitor()).parse(new StringReader(bibEntry));
+
+        BibEntry entry = result.getDatabase().getEntryByCitationKey("1137631").get();
+        entry.setField(StandardField.AUTHOR, "Mr. Author");
+
+        when(generalPreferences.getDefaultEncoding()).thenReturn(StandardCharsets.UTF_8);
+        when(savePreferences.shouldSaveInOriginalOrder()).thenReturn(true);
+        BibDatabaseContext context = new BibDatabaseContext(result.getDatabase(), result.getMetaData());
+
+        // we need a new writer because "\n" instead of "OS.NEWLINE"
+        bibWriter = new BibWriter(stringWriter, "\n");
+        databaseWriter = new BibtexDatabaseWriter(bibWriter, generalPreferences, savePreferences, entryTypesManager);
+        databaseWriter.savePartOfDatabase(context, result.getDatabase().getEntries());
+        assertEquals(bibEntry, stringWriter.toString());
+    }
+
     @Test
     void roundtripWithUserCommentAndEntryChange() throws Exception {
         Path testBibtexFile = Path.of("src/test/resources/testbib/bibWithUserComments.bib");
@@ -431,7 +522,7 @@ void writeSavedSerializationOfEntryIfUnchanged() throws Exception {
 
         databaseWriter.savePartOfDatabase(bibtexContext, Collections.singletonList(entry));
 
-        assertEquals("presaved serialization", stringWriter.toString());
+        assertEquals("presaved serialization" + OS.NEWLINE, stringWriter.toString());
     }
 
     @Test
@@ -446,9 +537,7 @@ void reformatEntryIfAskedToDoSo() throws Exception {
         when(savePreferences.shouldReformatFile()).thenReturn(true);
         databaseWriter.savePartOfDatabase(bibtexContext, Collections.singletonList(entry));
 
-        assertEquals(
-                OS.NEWLINE
-                        + "@Article{," + OS.NEWLINE + "  author = {Mr. author}," + OS.NEWLINE + "}"
+        assertEquals("@Article{," + OS.NEWLINE + "  author = {Mr. author}," + OS.NEWLINE + "}"
                         + OS.NEWLINE,
                 stringWriter.toString());
     }
@@ -461,7 +550,7 @@ void writeSavedSerializationOfStringIfUnchanged() throws Exception {
 
         databaseWriter.savePartOfDatabase(bibtexContext, Collections.emptyList());
 
-        assertEquals("serialization", stringWriter.toString());
+        assertEquals("serialization" + OS.NEWLINE, stringWriter.toString());
     }
 
     @Test
@@ -473,7 +562,7 @@ void reformatStringIfAskedToDoSo() throws Exception {
         when(savePreferences.shouldReformatFile()).thenReturn(true);
         databaseWriter.savePartOfDatabase(bibtexContext, Collections.emptyList());
 
-        assertEquals(OS.NEWLINE + "@String{name = {content}}" + OS.NEWLINE, stringWriter.toString());
+        assertEquals("@String{name = {content}}" + OS.NEWLINE, stringWriter.toString());
     }
 
     @Test
@@ -487,9 +576,7 @@ void writeSaveActions() throws Exception {
 
         databaseWriter.savePartOfDatabase(bibtexContext, Collections.emptyList());
 
-        assertEquals(
-                OS.NEWLINE +
-                        "@Comment{jabref-meta: saveActions:enabled;"
+        assertEquals("@Comment{jabref-meta: saveActions:enabled;"
                         + OS.NEWLINE
                         + "day[upper_case]" + OS.NEWLINE
                         + "journal[title_case]" + OS.NEWLINE
@@ -508,8 +595,7 @@ void writeSaveOrderConfig() throws Exception {
 
         databaseWriter.savePartOfDatabase(bibtexContext, Collections.emptyList());
 
-        assertEquals(OS.NEWLINE
-                + "@Comment{jabref-meta: saveOrderConfig:specified;author;false;year;true;abstract;false;}"
+        assertEquals("@Comment{jabref-meta: saveOrderConfig:specified;author;false;year;true;abstract;false;}"
                 + OS.NEWLINE, stringWriter.toString());
     }
 
@@ -522,7 +608,7 @@ void writeCustomKeyPattern() throws Exception {
 
         databaseWriter.savePartOfDatabase(bibtexContext, Collections.emptyList());
 
-        assertEquals(OS.NEWLINE + "@Comment{jabref-meta: keypattern_article:articleTest;}" + OS.NEWLINE
+        assertEquals("@Comment{jabref-meta: keypattern_article:articleTest;}" + OS.NEWLINE
                         + OS.NEWLINE + "@Comment{jabref-meta: keypatterndefault:test;}" + OS.NEWLINE,
                 stringWriter.toString());
     }
@@ -533,7 +619,7 @@ void writeBiblatexMode() throws Exception {
 
         databaseWriter.savePartOfDatabase(bibtexContext, Collections.emptyList());
 
-        assertEquals(OS.NEWLINE + "@Comment{jabref-meta: databaseType:biblatex;}" + OS.NEWLINE,
+        assertEquals("@Comment{jabref-meta: databaseType:biblatex;}" + OS.NEWLINE,
                 stringWriter.toString());
     }
 
@@ -543,7 +629,7 @@ void writeProtectedFlag() throws Exception {
 
         databaseWriter.savePartOfDatabase(bibtexContext, Collections.emptyList());
 
-        assertEquals(OS.NEWLINE + "@Comment{jabref-meta: protectedFlag:true;}" + OS.NEWLINE,
+        assertEquals("@Comment{jabref-meta: protectedFlag:true;}" + OS.NEWLINE,
                 stringWriter.toString());
     }
 
@@ -555,7 +641,7 @@ void writeFileDirectories() throws Exception {
 
         databaseWriter.savePartOfDatabase(bibtexContext, Collections.emptyList());
 
-        assertEquals(OS.NEWLINE + "@Comment{jabref-meta: fileDirectory:\\\\Literature\\\\;}" + OS.NEWLINE +
+        assertEquals("@Comment{jabref-meta: fileDirectory:\\\\Literature\\\\;}" + OS.NEWLINE +
                 OS.NEWLINE + "@Comment{jabref-meta: fileDirectory-defaultOwner-user:D:\\\\Documents;}"
                 + OS.NEWLINE + OS.NEWLINE + "@Comment{jabref-meta: fileDirectoryLatex-defaultOwner-user:D:\\\\Latex;}" + OS.NEWLINE, stringWriter.toString());
     }
@@ -589,9 +675,7 @@ void writeEntriesSorted() throws Exception {
 
         databaseWriter.savePartOfDatabase(bibtexContext, database.getEntries());
 
-        assertEquals(
-                OS.NEWLINE +
-                        "@Article{," + OS.NEWLINE +
+        assertEquals("@Article{," + OS.NEWLINE +
                         "  author = {A}," + OS.NEWLINE +
                         "  year   = {2010}," + OS.NEWLINE +
                         "}" + OS.NEWLINE + OS.NEWLINE +
@@ -632,9 +716,7 @@ void writeEntriesInOriginalOrderWhenNoSaveOrderConfigIsSetInMetadata() throws Ex
         when(savePreferences.shouldSaveInOriginalOrder()).thenReturn(false);
         databaseWriter.savePartOfDatabase(bibtexContext, database.getEntries());
 
-        assertEquals(
-                OS.NEWLINE +
-                        "@Article{," + OS.NEWLINE +
+        assertEquals("@Article{," + OS.NEWLINE +
                         "  author = {A}," + OS.NEWLINE +
                         "  year   = {2010}," + OS.NEWLINE +
                         "}" + OS.NEWLINE + OS.NEWLINE +
@@ -658,8 +740,7 @@ void trimFieldContents() throws IOException {
 
         databaseWriter.saveDatabase(bibtexContext);
 
-        assertEquals(
-                OS.NEWLINE + "@Article{," + OS.NEWLINE +
+        assertEquals("@Article{," + OS.NEWLINE +
                         "  note = {some note}," + OS.NEWLINE +
                         "}" + OS.NEWLINE,
                 stringWriter.toString());
@@ -675,8 +756,7 @@ void newlineAtEndOfAbstractFieldIsDeleted() throws Exception {
 
         databaseWriter.saveDatabase(bibtexContext);
 
-        assertEquals(
-                OS.NEWLINE + "@Article{," + OS.NEWLINE +
+        assertEquals("@Article{," + OS.NEWLINE +
                         "  abstract = {" + text + "}," + OS.NEWLINE +
                         "}" + OS.NEWLINE,
                 stringWriter.toString());
@@ -684,7 +764,9 @@ void newlineAtEndOfAbstractFieldIsDeleted() throws Exception {
 
     @Test
     void roundtripWithContentSelectorsAndUmlauts() throws Exception {
-        String fileContent = "% Encoding: UTF-8" + OS.NEWLINE + OS.NEWLINE + "@Comment{jabref-meta: selector_journal:Test {\\\\\"U}mlaut;}" + OS.NEWLINE;
+        String encodingHeader = "% Encoding: UTF-8" + OS.NEWLINE + OS.NEWLINE;
+        String commentEntry = "@Comment{jabref-meta: selector_journal:Test {\\\\\"U}mlaut;}" + OS.NEWLINE;
+        String fileContent = encodingHeader + commentEntry;
         Charset encoding = StandardCharsets.UTF_8;
 
         ParserResult firstParse = new BibtexParser(importFormatPreferences, fileMonitor).parse(new StringReader(fileContent));
@@ -695,7 +777,7 @@ void roundtripWithContentSelectorsAndUmlauts() throws Exception {
 
         databaseWriter.savePartOfDatabase(context, firstParse.getDatabase().getEntries());
 
-        assertEquals(fileContent, stringWriter.toString());
+        assertEquals(commentEntry, stringWriter.toString());
     }
 
     @Test
@@ -728,11 +810,11 @@ void saveAlsoSavesSecondModification() throws Exception {
 
         // write a second time
         stringWriter = new StringWriter();
-        databaseWriter = new BibtexDatabaseWriter(stringWriter, generalPreferences, savePreferences, entryTypesManager);
+        bibWriter = new BibWriter(stringWriter, OS.NEWLINE);
+        databaseWriter = new BibtexDatabaseWriter(bibWriter, generalPreferences, savePreferences, entryTypesManager);
         databaseWriter.savePartOfDatabase(context, firstParse.getDatabase().getEntries());
 
-        assertEquals(OS.NEWLINE +
-                "@Article{test," + OS.NEWLINE +
+        assertEquals("@Article{test," + OS.NEWLINE +
                 "  author  = {Test}," + OS.NEWLINE +
                 "  journal = {International Journal of Something}," + OS.NEWLINE +
                 "  note    = {some note}," + OS.NEWLINE +
@@ -745,12 +827,12 @@ void saveAlsoSavesSecondModification() throws Exception {
     @Test
     void saveReturnsToOriginalEntryWhenEntryIsFlaggedUnchanged() throws Exception {
         // @formatter:off
-        String bibtexEntry = OS.NEWLINE + "@Article{test," + OS.NEWLINE +
+        String bibtexEntry = "@Article{test," + OS.NEWLINE +
                 "  Author                   = {Foo Bar}," + OS.NEWLINE +
                 "  Journal                  = {International Journal of Something}," + OS.NEWLINE +
                 "  Number                   = {1}," + OS.NEWLINE +
                 "  Note                     = {some note}," + OS.NEWLINE +
-                "}";
+                "}" + OS.NEWLINE;
         // @formatter:on
 
         // read in bibtex string
@@ -766,8 +848,6 @@ void saveReturnsToOriginalEntryWhenEntryIsFlaggedUnchanged() throws Exception {
         entry.setChanged(false);
 
         // write entry
-        stringWriter = new StringWriter();
-        databaseWriter = new BibtexDatabaseWriter(stringWriter, generalPreferences, savePreferences, entryTypesManager);
         BibDatabaseContext context = new BibDatabaseContext(firstParse.getDatabase(), firstParse.getMetaData());
         databaseWriter.savePartOfDatabase(context, firstParse.getDatabase().getEntries());
 
@@ -775,14 +855,14 @@ void saveReturnsToOriginalEntryWhenEntryIsFlaggedUnchanged() throws Exception {
     }
 
     @Test
-    void saveReturnsToOriginalEntryWhenEntryIsFlaggedUnchangedEvenInThePrecenseOfSavedModifications() throws Exception {
+    void saveReturnsToOriginalEntryWhenEntryIsFlaggedUnchangedEvenInThePresenceOfSavedModifications() throws Exception {
         // @formatter:off
-        String bibtexEntry = OS.NEWLINE + "@Article{test," + OS.NEWLINE +
+        String bibtexEntry = "@Article{test," + OS.NEWLINE +
                 "  Author                   = {Foo Bar}," + OS.NEWLINE +
                 "  Journal                  = {International Journal of Something}," + OS.NEWLINE +
                 "  Note                     = {some note}," + OS.NEWLINE +
                 "  Number                   = {1}," + OS.NEWLINE +
-                "}";
+                "}" + OS.NEWLINE;
         // @formatter:on
 
         // read in bibtex string
@@ -805,7 +885,8 @@ void saveReturnsToOriginalEntryWhenEntryIsFlaggedUnchangedEvenInThePrecenseOfSav
 
         // write a second time
         stringWriter = new StringWriter();
-        databaseWriter = new BibtexDatabaseWriter(stringWriter, generalPreferences, savePreferences, entryTypesManager);
+        bibWriter = new BibWriter(stringWriter, OS.NEWLINE);
+        databaseWriter = new BibtexDatabaseWriter(bibWriter, generalPreferences, savePreferences, entryTypesManager);
         databaseWriter.savePartOfDatabase(context, firstParse.getDatabase().getEntries());
 
         // returns tu original entry, not to the last saved one
diff --git a/src/test/java/org/jabref/logic/importer/fileformat/BibtexParserTest.java b/src/test/java/org/jabref/logic/importer/fileformat/BibtexParserTest.java
index e0958825e03..12ca044d5bf 100644
--- a/src/test/java/org/jabref/logic/importer/fileformat/BibtexParserTest.java
+++ b/src/test/java/org/jabref/logic/importer/fileformat/BibtexParserTest.java
@@ -343,8 +343,8 @@ void parseRecognizesEntryWithAtInField() throws IOException {
     @Test
     void parseRecognizesEntryPrecedingComment() throws IOException {
         String comment = "@Comment{@article{myarticle,}" + OS.NEWLINE
-                + "@inproceedings{blabla, title={the proceedings of bl@bl@}; }" + OS.NEWLINE + "}";
-        String entryWithComment = comment + OS.NEWLINE + "@article{test,author={Ed von T@st}}";
+                + "@inproceedings{blabla, title={the proceedings of bl@bl@}; }" + OS.NEWLINE + "}" + OS.NEWLINE;
+        String entryWithComment = comment + "@article{test,author={Ed von T@st}}";
         BibEntry expected = new BibEntry(StandardEntryType.Article)
                 .withField(InternalField.KEY_FIELD, "test")
                 .withField(StandardField.AUTHOR, "Ed von T@st");
@@ -1197,7 +1197,7 @@ void parseSavesOneNewlineAfterEntryInParsedSerialization() throws IOException {
     }
 
     @Test
-    void parseSavesNewlinesBeforeEntryInParsedSerialization() throws IOException {
+    void parseSavesAllButOneNewlinesBeforeEntryInParsedSerialization() throws IOException {
         String testEntry = "@article{test,author={Ed von Test}}";
         ParserResult result = parser
                 .parse(new StringReader(OS.NEWLINE + OS.NEWLINE + OS.NEWLINE + testEntry));
@@ -1206,11 +1206,12 @@ void parseSavesNewlinesBeforeEntryInParsedSerialization() throws IOException {
         BibEntry parsedEntry = parsedEntries.iterator().next();
 
         assertEquals(1, parsedEntries.size());
-        assertEquals(OS.NEWLINE + OS.NEWLINE + OS.NEWLINE + testEntry, parsedEntry.getParsedSerialization());
+        // The first newline is removed, because JabRef interprets that always as block separator
+        assertEquals(OS.NEWLINE + OS.NEWLINE + testEntry, parsedEntry.getParsedSerialization());
     }
 
     @Test
-    void parseRemovesEncodingLineInParsedSerialization() throws IOException {
+    void parseRemovesEncodingLineAndSeparatorInParsedSerialization() throws IOException {
         String testEntry = "@article{test,author={Ed von Test}}";
         ParserResult result = parser.parse(
                 new StringReader(SavePreferences.ENCODING_PREFIX + OS.NEWLINE + OS.NEWLINE + OS.NEWLINE + testEntry));
@@ -1219,7 +1220,9 @@ void parseRemovesEncodingLineInParsedSerialization() throws IOException {
         BibEntry parsedEntry = parsedEntries.iterator().next();
 
         assertEquals(1, parsedEntries.size());
-        assertEquals(OS.NEWLINE + OS.NEWLINE + testEntry, parsedEntry.getParsedSerialization());
+        // First two newlines are removed because of removal of "Encoding"
+        // Third newline removed because of block functionality
+        assertEquals(testEntry, parsedEntry.getParsedSerialization());
     }
 
     @Test
@@ -1242,7 +1245,8 @@ void parseSavesNewlinesBetweenEntriesInParsedSerialization() throws IOException
 
         assertEquals(2, parsedEntries.size());
         assertEquals(testEntryOne + OS.NEWLINE, first.getParsedSerialization());
-        assertEquals(OS.NEWLINE + OS.NEWLINE + testEntryTwo, second.getParsedSerialization());
+        // one newline is removed, because it is written by JabRef's block functionality
+        assertEquals(OS.NEWLINE + testEntryTwo, second.getParsedSerialization());
     }
 
     @Test
@@ -1299,6 +1303,32 @@ void parseRecognizesSaveActionsAfterEntry() throws IOException {
                 saveActions.getConfiguredActions());
     }
 
+    @Test
+    void parseRecognizesCRLFLineBreak() throws IOException {
+        ParserResult result = parser.parse(
+                new StringReader("@InProceedings{6055279,\r\n" + "  Title                    = {Educational session 1},\r\n"
+                        + "  Booktitle                = {Custom Integrated Circuits Conference (CICC), 2011 IEEE},\r\n"
+                        + "  Year                     = {2011},\r\n" + "  Month                    = {Sept},\r\n"
+                        + "  Pages                    = {1-7},\r\n"
+                        + "  Abstract                 = {Start of the above-titled section of the conference proceedings record.},\r\n"
+                        + "  DOI                      = {10.1109/CICC.2011.6055279},\r\n"
+                        + "  ISSN                     = {0886-5930}\r\n" + "}\r\n"));
+        assertEquals("\r\n", result.getDatabase().getNewLineSeparator());
+    }
+
+    @Test
+    void parseRecognizesLFLineBreak() throws IOException {
+        ParserResult result = parser.parse(
+                new StringReader("@InProceedings{6055279,\n" + "  Title                    = {Educational session 1},\n"
+                        + "  Booktitle                = {Custom Integrated Circuits Conference (CICC), 2011 IEEE},\n"
+                        + "  Year                     = {2011},\n" + "  Month                    = {Sept},\n"
+                        + "  Pages                    = {1-7},\n"
+                        + "  Abstract                 = {Start of the above-titled section of the conference proceedings record.},\n"
+                        + "  DOI                      = {10.1109/CICC.2011.6055279},\n"
+                        + "  ISSN                     = {0886-5930}\n" + "}\n"));
+        assertEquals("\n", result.getDatabase().getNewLineSeparator());
+    }
+
     @Test
     void integrationTestSaveActions() throws IOException {
         ParserResult parserResult = parser
diff --git a/src/test/resources/testbib/articleWithMonths.bib b/src/test/resources/testbib/articleWithMonths.bib
index 6898d754ade..0664116e9c9 100644
--- a/src/test/resources/testbib/articleWithMonths.bib
+++ b/src/test/resources/testbib/articleWithMonths.bib
@@ -1,4 +1,3 @@
-% Encoding: UTF-8
 @Article{constant,
 	month = apr
 }
diff --git a/src/test/resources/testbib/bibWithUserCommentAndEntryChange.bib b/src/test/resources/testbib/bibWithUserCommentAndEntryChange.bib
index 326c45842a3..17933272edd 100644
--- a/src/test/resources/testbib/bibWithUserCommentAndEntryChange.bib
+++ b/src/test/resources/testbib/bibWithUserCommentAndEntryChange.bib
@@ -1,5 +1,3 @@
-% Encoding: UTF-8
-
 @Preamble{preamble}
 
 @String{firstString  = {my first string}}
diff --git a/src/test/resources/testbib/bibWithUserComments.bib b/src/test/resources/testbib/bibWithUserComments.bib
index 90685b10eac..fbe2d05c7b4 100644
--- a/src/test/resources/testbib/bibWithUserComments.bib
+++ b/src/test/resources/testbib/bibWithUserComments.bib
@@ -1,5 +1,3 @@
-% Encoding: UTF-8
-
 @Preamble{preamble}
 
 @String{firstString  = {my first string}}
diff --git a/src/test/resources/testbib/complex.bib b/src/test/resources/testbib/complex.bib
index a46342912bf..8fb2ba87f74 100644
--- a/src/test/resources/testbib/complex.bib
+++ b/src/test/resources/testbib/complex.bib
@@ -1,5 +1,3 @@
-% Encoding: UTF-8
-
 @Preamble{preamble}
 
 This is some arbitrary user comment that should be preserved
diff --git a/src/test/resources/testbib/unknownMetaData.bib b/src/test/resources/testbib/unknownMetaData.bib
index d32a1b9a382..69ed04d5466 100644
--- a/src/test/resources/testbib/unknownMetaData.bib
+++ b/src/test/resources/testbib/unknownMetaData.bib
@@ -1,5 +1,3 @@
-% Encoding: UTF-8
-
 @Article{author2017title,
   author  = {Author},
   title   = {Title},