diff --git a/besu/src/main/java/org/hyperledger/besu/cli/options/SynchronizerOptions.java b/besu/src/main/java/org/hyperledger/besu/cli/options/SynchronizerOptions.java
index d6a1edeb8da..a61fe78664e 100644
--- a/besu/src/main/java/org/hyperledger/besu/cli/options/SynchronizerOptions.java
+++ b/besu/src/main/java/org/hyperledger/besu/cli/options/SynchronizerOptions.java
@@ -14,6 +14,8 @@
  */
 package org.hyperledger.besu.cli.options;
 
+import static org.hyperledger.besu.ethereum.eth.sync.snapsync.SnapSyncConfiguration.DEFAULT_SNAP_SYNC_SAVE_PRE_MERGE_HEADERS_ONLY_ENABLED;
+
 import org.hyperledger.besu.ethereum.eth.sync.SynchronizerConfiguration;
 import org.hyperledger.besu.ethereum.eth.sync.snapsync.ImmutableSnapSyncConfiguration;
 import org.hyperledger.besu.ethereum.eth.sync.snapsync.SnapSyncConfiguration;
@@ -87,6 +89,9 @@ public class SynchronizerOptions implements CLIOptions<SynchronizerConfiguration
 
   private static final String SNAP_SYNC_BFT_ENABLED_FLAG = "--Xsnapsync-bft-enabled";
 
+  private static final String SNAP_SYNC_SAVE_PRE_MERGE_HEADERS_ONLY_FLAG =
+      "--Xsnapsync-synchronizer-pre-merge-headers-only-enabled";
+
   /**
    * Parse block propagation range.
    *
@@ -333,6 +338,16 @@ public void parseBlockPropagationRange(final String arg) {
   private Boolean snapTransactionIndexingEnabled =
       SnapSyncConfiguration.DEFAULT_SNAP_SYNC_TRANSACTION_INDEXING_ENABLED;
 
+  @CommandLine.Option(
+      names = SNAP_SYNC_SAVE_PRE_MERGE_HEADERS_ONLY_FLAG,
+      paramLabel = "<Boolean>",
+      hidden = true,
+      arity = "0..1",
+      description =
+          "Enable snap sync downloader to save only headers for blocks before the merge. (default: ${DEFAULT-VALUE})")
+  private Boolean snapSyncSavePreMergeHeadersOnlyEnabled =
+      DEFAULT_SNAP_SYNC_SAVE_PRE_MERGE_HEADERS_ONLY_ENABLED;
+
   private SynchronizerOptions() {}
 
   /**
@@ -414,6 +429,8 @@ public static SynchronizerOptions fromConfig(final SynchronizerConfiguration con
     options.snapsyncServerEnabled = config.getSnapSyncConfiguration().isSnapServerEnabled();
     options.snapTransactionIndexingEnabled =
         config.getSnapSyncConfiguration().isSnapSyncTransactionIndexingEnabled();
+    options.snapSyncSavePreMergeHeadersOnlyEnabled =
+        config.isSnapSyncSavePreMergeHeadersOnlyEnabled();
     return options;
   }
 
@@ -450,6 +467,7 @@ public SynchronizerConfiguration.Builder toDomainObject() {
             .build());
     builder.checkpointPostMergeEnabled(checkpointPostMergeSyncEnabled);
     builder.isPeerTaskSystemEnabled(isPeerTaskSystemEnabled);
+    builder.snapSyncSavePreMergeHeadersOnlyEnabled(snapSyncSavePreMergeHeadersOnlyEnabled);
     return builder;
   }
 
@@ -506,7 +524,9 @@ public List<String> getCLIOptions() {
             SNAP_SERVER_ENABLED_FLAG,
             OptionParser.format(snapsyncServerEnabled),
             SNAP_TRANSACTION_INDEXING_ENABLED_FLAG,
-            OptionParser.format(snapTransactionIndexingEnabled));
+            OptionParser.format(snapTransactionIndexingEnabled),
+            SNAP_SYNC_SAVE_PRE_MERGE_HEADERS_ONLY_FLAG,
+            OptionParser.format(snapSyncSavePreMergeHeadersOnlyEnabled));
     return value;
   }
 }
diff --git a/besu/src/test/java/org/hyperledger/besu/cli/options/SynchronizerOptionsTest.java b/besu/src/test/java/org/hyperledger/besu/cli/options/SynchronizerOptionsTest.java
index 70d94c41a78..a5ba174ef60 100644
--- a/besu/src/test/java/org/hyperledger/besu/cli/options/SynchronizerOptionsTest.java
+++ b/besu/src/test/java/org/hyperledger/besu/cli/options/SynchronizerOptionsTest.java
@@ -79,7 +79,9 @@ protected SynchronizerConfiguration.Builder createCustomizedDomainObject() {
                     SnapSyncConfiguration.DEFAULT_BYTECODE_COUNT_PER_REQUEST + 2)
                 .isSnapServerEnabled(Boolean.TRUE)
                 .isSnapSyncTransactionIndexingEnabled(Boolean.TRUE)
-                .build());
+                .build())
+        .snapSyncSavePreMergeHeadersOnlyEnabled(
+            SnapSyncConfiguration.DEFAULT_SNAP_SYNC_SAVE_PRE_MERGE_HEADERS_ONLY_ENABLED);
   }
 
   @Override
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/chain/DefaultBlockchain.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/chain/DefaultBlockchain.java
index a2c6e8f5844..be6d793b432 100644
--- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/chain/DefaultBlockchain.java
+++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/chain/DefaultBlockchain.java
@@ -112,9 +112,14 @@ private DefaultBlockchain(
     final Hash chainHead = blockchainStorage.getChainHead().get();
     chainHeader = blockchainStorage.getBlockHeader(chainHead).get();
     totalDifficulty = blockchainStorage.getTotalDifficulty(chainHead).get();
-    final BlockBody chainHeadBody = blockchainStorage.getBlockBody(chainHead).get();
-    chainHeadTransactionCount = chainHeadBody.getTransactions().size();
-    chainHeadOmmerCount = chainHeadBody.getOmmers().size();
+
+    blockchainStorage
+        .getBlockBody(chainHead)
+        .ifPresent(
+            headBlockBody -> {
+              chainHeadTransactionCount = headBlockBody.getTransactions().size();
+              chainHeadOmmerCount = headBlockBody.getOmmers().size();
+            });
 
     this.reorgLoggingThreshold = reorgLoggingThreshold;
     this.blockChoiceRule = heaviestChainBlockChoiceRule;
@@ -433,6 +438,18 @@ public synchronized void storeBlock(final Block block, final List<TransactionRec
     appendBlockHelper(new BlockWithReceipts(block, receipts), true, true);
   }
 
+  @Override
+  public void unsafeStoreHeader(final BlockHeader blockHeader, final Difficulty totalDifficulty) {
+    final BlockchainStorage.Updater updater = blockchainStorage.updater();
+    updater.putBlockHeader(blockHeader.getHash(), blockHeader);
+    updater.putBlockHash(blockHeader.getNumber(), blockHeader.getBlockHash());
+    updater.putTotalDifficulty(blockHeader.getHash(), totalDifficulty);
+    this.chainHeader = blockHeader;
+    this.totalDifficulty = totalDifficulty;
+    updater.setChainHead(blockHeader.getBlockHash());
+    updater.commit();
+  }
+
   private void cacheBlockData(final Block block, final List<TransactionReceipt> receipts) {
     blockHeadersCache.ifPresent(cache -> cache.put(block.getHash(), block.getHeader()));
     blockBodiesCache.ifPresent(cache -> cache.put(block.getHash(), block.getBody()));
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/chain/MutableBlockchain.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/chain/MutableBlockchain.java
index 1f2acbdeff9..35a57e5bcfe 100644
--- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/chain/MutableBlockchain.java
+++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/chain/MutableBlockchain.java
@@ -61,6 +61,13 @@ public interface MutableBlockchain extends Blockchain {
    */
   void storeBlock(Block block, List<TransactionReceipt> receipts);
 
+  /**
+   * Store a block header to the blockchain, updating the chain state.
+   *
+   * @param blockHeader The block header to store.
+   */
+  void unsafeStoreHeader(BlockHeader blockHeader, Difficulty totalDifficulty);
+
   void unsafeImportBlock(
       final Block block,
       final List<TransactionReceipt> receipts,
diff --git a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/DownloadPipelineFactory.java b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/DownloadPipelineFactory.java
index f8dff31d6b6..4871d301951 100644
--- a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/DownloadPipelineFactory.java
+++ b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/DownloadPipelineFactory.java
@@ -30,7 +30,7 @@ public interface DownloadPipelineFactory {
    * @param target the target the chain download is working to catch up to.
    * @return the created but not yet started pipeline.
    */
-  Pipeline<?> createDownloadPipelineForSyncTarget(SyncTarget target);
+  Pipeline<?> createDownloadPipelineForSyncTarget(SyncState syncState, SyncTarget target);
 
   CompletionStage<Void> startPipeline(
       EthScheduler scheduler, SyncState syncState, SyncTarget syncTarget, Pipeline<?> pipeline);
diff --git a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/PipelineChainDownloader.java b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/PipelineChainDownloader.java
index 8f2ee1d48a0..7f59cc10233 100644
--- a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/PipelineChainDownloader.java
+++ b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/PipelineChainDownloader.java
@@ -172,7 +172,8 @@ private synchronized CompletionStage<Void> startDownloadForSyncTarget(final Sync
         .addArgument(() -> target.commonAncestor().getNumber())
         .addArgument(() -> target.commonAncestor().getBlockHash())
         .log();
-    currentDownloadPipeline = downloadPipelineFactory.createDownloadPipelineForSyncTarget(target);
+    currentDownloadPipeline =
+        downloadPipelineFactory.createDownloadPipelineForSyncTarget(syncState, target);
     return downloadPipelineFactory.startPipeline(
         scheduler, syncState, target, currentDownloadPipeline);
   }
diff --git a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/SavePreMergeHeadersStep.java b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/SavePreMergeHeadersStep.java
new file mode 100644
index 00000000000..f260a9c6188
--- /dev/null
+++ b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/SavePreMergeHeadersStep.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright contributors to Hyperledger Besu.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package org.hyperledger.besu.ethereum.eth.sync;
+
+import static org.hyperledger.besu.util.log.LogUtil.throttledLog;
+
+import org.hyperledger.besu.ethereum.chain.MutableBlockchain;
+import org.hyperledger.besu.ethereum.core.BlockHeader;
+import org.hyperledger.besu.ethereum.core.Difficulty;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/** A step in the synchronization process that saves historical block headers. */
+public class SavePreMergeHeadersStep implements Function<BlockHeader, Stream<BlockHeader>> {
+  private static final Logger LOG = LoggerFactory.getLogger(SavePreMergeHeadersStep.class);
+  private final MutableBlockchain blockchain;
+  private final long mergeBlockNumber;
+
+  private final AtomicBoolean shouldLog = new AtomicBoolean(true);
+  private static final int LOG_REPEAT_DELAY_SECONDS = 30;
+  private static final int LOG_PROGRESS_INTERVAL = 1000;
+
+  public SavePreMergeHeadersStep(final MutableBlockchain blockchain, final long mergeBlockNumber) {
+    this.blockchain = blockchain;
+    this.mergeBlockNumber = mergeBlockNumber;
+  }
+
+  @Override
+  public Stream<BlockHeader> apply(final BlockHeader blockHeader) {
+    long blockNumber = blockHeader.getNumber();
+    if (isPostMergeBlock(blockNumber)) {
+      return Stream.of(blockHeader);
+    }
+    storeBlockHeader(blockHeader);
+    logProgress(blockHeader);
+    return Stream.empty();
+  }
+
+  private boolean isPostMergeBlock(final long blockNumber) {
+    return blockNumber >= mergeBlockNumber;
+  }
+
+  private void storeBlockHeader(final BlockHeader blockHeader) {
+    Difficulty difficulty = blockchain.calculateTotalDifficulty(blockHeader);
+    blockchain.unsafeStoreHeader(blockHeader, difficulty);
+  }
+
+  private void logProgress(final BlockHeader blockHeader) {
+    long lastPoWBlockNumber = mergeBlockNumber - 1;
+    if (blockHeader.getNumber() == lastPoWBlockNumber) {
+      LOG.info("Pre-merge headers import completed at block {}", blockHeader.toLogString());
+    } else {
+      long blockNumber = blockHeader.getNumber();
+      if (blockNumber % LOG_PROGRESS_INTERVAL == 0) {
+        double importPercent = (double) (100 * blockNumber) / lastPoWBlockNumber;
+        throttledLog(
+            LOG::info,
+            String.format(
+                "Pre-merge headers import progress: %d of %d (%.2f%%)",
+                blockNumber, lastPoWBlockNumber, importPercent),
+            shouldLog,
+            LOG_REPEAT_DELAY_SECONDS);
+      }
+    }
+  }
+}
diff --git a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/SynchronizerConfiguration.java b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/SynchronizerConfiguration.java
index d72f76c213c..390a6cdef8e 100644
--- a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/SynchronizerConfiguration.java
+++ b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/SynchronizerConfiguration.java
@@ -86,6 +86,7 @@ public class SynchronizerConfiguration {
   private final long worldStateMinMillisBeforeStalling;
   private final long propagationManagerGetBlockTimeoutMillis;
   private final boolean isPeerTaskSystemEnabled;
+  private final boolean snapSyncSavePreMergeHeadersOnlyEnabled;
 
   private SynchronizerConfiguration(
       final int syncPivotDistance,
@@ -110,7 +111,8 @@ private SynchronizerConfiguration(
       final int maxTrailingPeers,
       final long propagationManagerGetBlockTimeoutMillis,
       final boolean checkpointPostMergeEnabled,
-      final boolean isPeerTaskSystemEnabled) {
+      final boolean isPeerTaskSystemEnabled,
+      final boolean snapSyncSavePreMergeHeadersOnlyEnabled) {
     this.syncPivotDistance = syncPivotDistance;
     this.fastSyncFullValidationRate = fastSyncFullValidationRate;
     this.syncMinimumPeerCount = syncMinimumPeerCount;
@@ -134,6 +136,7 @@ private SynchronizerConfiguration(
     this.propagationManagerGetBlockTimeoutMillis = propagationManagerGetBlockTimeoutMillis;
     this.checkpointPostMergeEnabled = checkpointPostMergeEnabled;
     this.isPeerTaskSystemEnabled = isPeerTaskSystemEnabled;
+    this.snapSyncSavePreMergeHeadersOnlyEnabled = snapSyncSavePreMergeHeadersOnlyEnabled;
   }
 
   public static Builder builder() {
@@ -263,6 +266,10 @@ public boolean isPeerTaskSystemEnabled() {
     return isPeerTaskSystemEnabled;
   }
 
+  public boolean isSnapSyncSavePreMergeHeadersOnlyEnabled() {
+    return snapSyncSavePreMergeHeadersOnlyEnabled;
+  }
+
   public static class Builder {
     private SyncMode syncMode = SyncMode.FULL;
     private int syncMinimumPeerCount = DEFAULT_SYNC_MINIMUM_PEERS;
@@ -288,6 +295,7 @@ public static class Builder {
     private long worldStateMinMillisBeforeStalling = DEFAULT_WORLD_STATE_MIN_MILLIS_BEFORE_STALLING;
     private int worldStateTaskCacheSize = DEFAULT_WORLD_STATE_TASK_CACHE_SIZE;
     private boolean isPeerTaskSystemEnabled = false;
+    private boolean snapSyncSavePreMergeHeadersOnlyEnabled = false;
 
     private long propagationManagerGetBlockTimeoutMillis =
         DEFAULT_PROPAGATION_MANAGER_GET_BLOCK_TIMEOUT_MILLIS;
@@ -419,6 +427,12 @@ public Builder isPeerTaskSystemEnabled(final boolean isPeerTaskSystemEnabled) {
       return this;
     }
 
+    public Builder snapSyncSavePreMergeHeadersOnlyEnabled(
+        final boolean snapSyncSavePreMergeHeadersOnlyEnabled) {
+      this.snapSyncSavePreMergeHeadersOnlyEnabled = snapSyncSavePreMergeHeadersOnlyEnabled;
+      return this;
+    }
+
     public SynchronizerConfiguration build() {
       return new SynchronizerConfiguration(
           syncPivotDistance,
@@ -443,7 +457,8 @@ public SynchronizerConfiguration build() {
           maxTrailingPeers,
           propagationManagerGetBlockTimeoutMillis,
           checkpointPostMergeEnabled,
-          isPeerTaskSystemEnabled);
+          isPeerTaskSystemEnabled,
+          snapSyncSavePreMergeHeadersOnlyEnabled);
     }
   }
 }
diff --git a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/FastSyncDownloadPipelineFactory.java b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/FastSyncDownloadPipelineFactory.java
index 25e799e58d1..d55be96236a 100644
--- a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/FastSyncDownloadPipelineFactory.java
+++ b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/FastSyncDownloadPipelineFactory.java
@@ -29,7 +29,9 @@
 import org.hyperledger.besu.ethereum.eth.sync.DownloadBodiesStep;
 import org.hyperledger.besu.ethereum.eth.sync.DownloadHeadersStep;
 import org.hyperledger.besu.ethereum.eth.sync.DownloadPipelineFactory;
+import org.hyperledger.besu.ethereum.eth.sync.SavePreMergeHeadersStep;
 import org.hyperledger.besu.ethereum.eth.sync.SynchronizerConfiguration;
+import org.hyperledger.besu.ethereum.eth.sync.fastsync.checkpoint.Checkpoint;
 import org.hyperledger.besu.ethereum.eth.sync.fullsync.SyncTerminationCondition;
 import org.hyperledger.besu.ethereum.eth.sync.range.RangeHeadersFetcher;
 import org.hyperledger.besu.ethereum.eth.sync.range.RangeHeadersValidationStep;
@@ -112,8 +114,8 @@ public CompletionStage<Void> startPipeline(
   }
 
   @Override
-  public Pipeline<SyncTargetRange> createDownloadPipelineForSyncTarget(final SyncTarget target) {
-
+  public Pipeline<SyncTargetRange> createDownloadPipelineForSyncTarget(
+      final SyncState syncState, final SyncTarget target) {
     final int downloaderParallelism = syncConfig.getDownloaderParallelism();
     final int headerRequestSize = syncConfig.getDownloaderHeaderRequestSize();
     final int singleHeaderBufferSize = headerRequestSize * downloaderParallelism;
@@ -139,6 +141,9 @@ public Pipeline<SyncTargetRange> createDownloadPipelineForSyncTarget(final SyncT
             metricsSystem);
     final RangeHeadersValidationStep validateHeadersJoinUpStep =
         new RangeHeadersValidationStep(protocolSchedule, protocolContext, detachedValidationPolicy);
+    final SavePreMergeHeadersStep savePreMergeHeadersStep =
+        new SavePreMergeHeadersStep(
+            protocolContext.getBlockchain(), getMergeHeaderBlockNumber(syncState));
     final DownloadBodiesStep downloadBodiesStep =
         new DownloadBodiesStep(protocolSchedule, ethContext, syncConfig, metricsSystem);
     final DownloadReceiptsStep downloadReceiptsStep =
@@ -167,6 +172,7 @@ public Pipeline<SyncTargetRange> createDownloadPipelineForSyncTarget(final SyncT
             "fastSync")
         .thenProcessAsyncOrdered("downloadHeaders", downloadHeadersStep, downloaderParallelism)
         .thenFlatMap("validateHeadersJoin", validateHeadersJoinUpStep, singleHeaderBufferSize)
+        .thenFlatMap("savePreMergeHeadersStep", savePreMergeHeadersStep, singleHeaderBufferSize)
         .inBatches(headerRequestSize)
         .thenProcessAsyncOrdered("downloadBodies", downloadBodiesStep, downloaderParallelism)
         .thenProcessAsyncOrdered("downloadReceipts", downloadReceiptsStep, downloaderParallelism)
@@ -194,4 +200,10 @@ protected boolean shouldContinueDownloadingFromPeer(
     }
     return shouldContinue;
   }
+
+  private long getMergeHeaderBlockNumber(final SyncState syncState) {
+    return syncConfig.isSnapSyncSavePreMergeHeadersOnlyEnabled()
+        ? syncState.getCheckpoint().map(Checkpoint::blockNumber).orElse(0L)
+        : 0L;
+  }
 }
diff --git a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/ImportBlocksStep.java b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/ImportBlocksStep.java
index 41edbfeb0f8..6a6f05ab360 100644
--- a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/ImportBlocksStep.java
+++ b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/ImportBlocksStep.java
@@ -14,6 +14,8 @@
  */
 package org.hyperledger.besu.ethereum.eth.sync.fastsync;
 
+import static org.hyperledger.besu.util.log.LogUtil.throttledLog;
+
 import org.hyperledger.besu.ethereum.ProtocolContext;
 import org.hyperledger.besu.ethereum.core.BlockHeader;
 import org.hyperledger.besu.ethereum.core.BlockImporter;
@@ -28,6 +30,7 @@
 import java.util.List;
 import java.util.OptionalLong;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Consumer;
 
 import com.google.common.annotations.VisibleForTesting;
@@ -36,7 +39,7 @@
 
 public class ImportBlocksStep implements Consumer<List<BlockWithReceipts>> {
   private static final Logger LOG = LoggerFactory.getLogger(ImportBlocksStep.class);
-  private static final long PRINT_DELAY = TimeUnit.SECONDS.toMillis(30L);
+  private static final int PRINT_DELAY_SECONDS = 30;
 
   private final ProtocolSchedule protocolSchedule;
   protected final ProtocolContext protocolContext;
@@ -48,6 +51,7 @@ public class ImportBlocksStep implements Consumer<List<BlockWithReceipts>> {
   private final BlockHeader pivotHeader;
   private final BodyValidationMode bodyValidationMode;
   private final boolean transactionIndexingEnabled;
+  private final AtomicBoolean shouldLog = new AtomicBoolean(true);
 
   public ImportBlocksStep(
       final ProtocolSchedule protocolSchedule,
@@ -91,13 +95,16 @@ public void accept(final List<BlockWithReceipts> blocksWithReceipts) {
       peerCount = ethContext.getEthPeers().peerCount();
     }
     final long endTime = System.nanoTime();
-
     accumulatedTime += TimeUnit.MILLISECONDS.convert(endTime - startTime, TimeUnit.NANOSECONDS);
-    if (accumulatedTime > PRINT_DELAY) {
+    if (shouldLog.get()) {
       final long blocksPercent = getBlocksPercent(lastBlock, pivotHeader.getNumber());
-      LOG.info(
-          "Block import progress: {} of {} ({}%), Peer count: {}",
-          lastBlock, pivotHeader.getNumber(), blocksPercent, peerCount);
+      throttledLog(
+          LOG::info,
+          String.format(
+              "Block import progress: %s of %s (%s%%), Peer count: %s",
+              lastBlock, pivotHeader.getNumber(), blocksPercent, peerCount),
+          shouldLog,
+          PRINT_DELAY_SECONDS);
       LOG.debug(
           "Completed importing chain segment {} to {} ({} blocks in {}ms), Peer count: {}",
           logStartBlock.getAsLong(),
diff --git a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fullsync/FullSyncDownloadPipelineFactory.java b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fullsync/FullSyncDownloadPipelineFactory.java
index 109dd42b1a3..661f8221395 100644
--- a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fullsync/FullSyncDownloadPipelineFactory.java
+++ b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fullsync/FullSyncDownloadPipelineFactory.java
@@ -81,7 +81,8 @@ public CompletionStage<Void> startPipeline(
   }
 
   @Override
-  public Pipeline<?> createDownloadPipelineForSyncTarget(final SyncTarget target) {
+  public Pipeline<?> createDownloadPipelineForSyncTarget(
+      final SyncState syncState, final SyncTarget target) {
     final int downloaderParallelism = syncConfig.getDownloaderParallelism();
     final int headerRequestSize = syncConfig.getDownloaderHeaderRequestSize();
     final int singleHeaderBufferSize = headerRequestSize * downloaderParallelism;
diff --git a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/snapsync/SnapSyncConfiguration.java b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/snapsync/SnapSyncConfiguration.java
index 996393aacb0..6394358d125 100644
--- a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/snapsync/SnapSyncConfiguration.java
+++ b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/snapsync/SnapSyncConfiguration.java
@@ -40,6 +40,7 @@ public class SnapSyncConfiguration {
 
   public static final Boolean DEFAULT_SNAP_SYNC_BFT_ENABLED = Boolean.FALSE;
   public static final Boolean DEFAULT_SNAP_SYNC_TRANSACTION_INDEXING_ENABLED = Boolean.TRUE;
+  public static final Boolean DEFAULT_SNAP_SYNC_SAVE_PRE_MERGE_HEADERS_ONLY_ENABLED = Boolean.FALSE;
 
   public static SnapSyncConfiguration getDefault() {
     return ImmutableSnapSyncConfiguration.builder().build();
diff --git a/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/PipelineChainDownloaderTest.java b/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/PipelineChainDownloaderTest.java
index f4402349058..9c35a59b007 100644
--- a/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/PipelineChainDownloaderTest.java
+++ b/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/PipelineChainDownloaderTest.java
@@ -100,7 +100,7 @@ public void shouldStartChainDownloadWhenTargetSelected() {
 
     selectTargetFuture.complete(syncTarget);
 
-    verify(downloadPipelineFactory).createDownloadPipelineForSyncTarget(syncTarget);
+    verify(downloadPipelineFactory).createDownloadPipelineForSyncTarget(syncState, syncTarget);
     verify(downloadPipelineFactory)
         .startPipeline(scheduler, syncState, syncTarget, downloadPipeline);
   }
@@ -245,7 +245,7 @@ public void shouldAbortPipelineIfCancelledAfterDownloadStarts() {
 
     final CompletableFuture<Void> result = chainDownloader.start();
     verify(syncTargetManager).findSyncTarget();
-    verify(downloadPipelineFactory).createDownloadPipelineForSyncTarget(syncTarget);
+    verify(downloadPipelineFactory).createDownloadPipelineForSyncTarget(syncState, syncTarget);
     verify(downloadPipelineFactory)
         .startPipeline(scheduler, syncState, syncTarget, downloadPipeline);
 
@@ -344,7 +344,7 @@ private void expectPipelineCreation(
       final SyncTarget syncTarget,
       final Pipeline<?> pipeline,
       final CompletableFuture<Void> completableFuture) {
-    when(downloadPipelineFactory.createDownloadPipelineForSyncTarget(syncTarget))
+    when(downloadPipelineFactory.createDownloadPipelineForSyncTarget(syncState, syncTarget))
         .thenReturn((Pipeline) pipeline);
     when(downloadPipelineFactory.startPipeline(scheduler, syncState, syncTarget, pipeline))
         .thenReturn(completableFuture);
diff --git a/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/SavePreMergeHeadersStepTest.java b/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/SavePreMergeHeadersStepTest.java
new file mode 100644
index 00000000000..21c90353098
--- /dev/null
+++ b/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/SavePreMergeHeadersStepTest.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright contributors to Besu.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package org.hyperledger.besu.ethereum.eth.sync.fastsync;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.hyperledger.besu.ethereum.chain.MutableBlockchain;
+import org.hyperledger.besu.ethereum.core.BlockHeader;
+import org.hyperledger.besu.ethereum.core.Difficulty;
+import org.hyperledger.besu.ethereum.eth.sync.SavePreMergeHeadersStep;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class SavePreMergeHeadersStepTest {
+  private MutableBlockchain blockchain;
+  private SavePreMergeHeadersStep savePreMergeHeadersStep;
+  private static final long MERGE_BLOCK_NUMBER = 1000;
+
+  @BeforeEach
+  void setUp() {
+    blockchain = mock(MutableBlockchain.class);
+    savePreMergeHeadersStep = new SavePreMergeHeadersStep(blockchain, MERGE_BLOCK_NUMBER);
+  }
+
+  @Test
+  void shouldSaveFullBlockForMergeBlock() {
+    BlockHeader blockHeader = createMockBlockHeader(MERGE_BLOCK_NUMBER);
+    Difficulty difficulty = mock(Difficulty.class);
+    when(blockchain.calculateTotalDifficulty(blockHeader)).thenReturn(difficulty);
+
+    Stream<BlockHeader> nextProcessingStateInput = savePreMergeHeadersStep.apply(blockHeader);
+
+    assertEquals(1, nextProcessingStateInput.count());
+    verify(blockchain, never()).unsafeStoreHeader(blockHeader, difficulty);
+  }
+
+  @Test
+  void shouldNotStoreOnlyBlockHeaderWhenPostMergeBlock() {
+    BlockHeader blockHeader = createMockBlockHeader(MERGE_BLOCK_NUMBER + 1);
+
+    Stream<BlockHeader> nextProcessingStateInput = savePreMergeHeadersStep.apply(blockHeader);
+
+    assertEquals(1, nextProcessingStateInput.count());
+    verify(blockchain, never()).unsafeStoreHeader(any(), any());
+  }
+
+  @Test
+  void shouldNotSaveIfCheckpointIsGenesisBlock() {
+    savePreMergeHeadersStep =
+        new SavePreMergeHeadersStep(blockchain, BlockHeader.GENESIS_BLOCK_NUMBER);
+
+    BlockHeader block0 = createMockBlockHeader(0);
+    BlockHeader block1 = createMockBlockHeader(1);
+
+    List<BlockHeader> nextProcessingStateInput = savePreMergeHeadersStep.apply(block0).toList();
+    assertEquals(1, nextProcessingStateInput.size());
+    assertEquals(nextProcessingStateInput.getFirst(), block0);
+
+    nextProcessingStateInput = savePreMergeHeadersStep.apply(block1).toList();
+    assertEquals(1, nextProcessingStateInput.size());
+    assertEquals(nextProcessingStateInput.getFirst(), block1);
+
+    verify(blockchain, never()).unsafeStoreHeader(any(), any());
+  }
+
+  @Test
+  void shouldStoreOnlyBlockHeaderWhenPreMergeBlock() {
+    BlockHeader blockHeader = createMockBlockHeader(MERGE_BLOCK_NUMBER - 1);
+    Difficulty difficulty = mock(Difficulty.class);
+    when(blockchain.calculateTotalDifficulty(blockHeader)).thenReturn(difficulty);
+
+    Stream<BlockHeader> nextProcessingStateInput = savePreMergeHeadersStep.apply(blockHeader);
+
+    assertEquals(0, nextProcessingStateInput.count());
+    verify(blockchain).unsafeStoreHeader(blockHeader, difficulty);
+  }
+
+  private BlockHeader createMockBlockHeader(final long blockNumber) {
+    BlockHeader blockHeader = mock(BlockHeader.class);
+    when(blockHeader.getNumber()).thenReturn(blockNumber);
+    return blockHeader;
+  }
+}