diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6244706407c..1d46646a94d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -33,6 +33,7 @@
 - Nodes in a permissioned chain maintain (and retry) connections to bootnodes [#7257](https://github.com/hyperledger/besu/pull/7257)
 - Promote experimental `besu storage x-trie-log` subcommand to production-ready [#7278](https://github.com/hyperledger/besu/pull/7278)
 - Enhanced BFT round-change diagnostics [#7271](https://github.com/hyperledger/besu/pull/7271)
+- `--Xsnapsync-bft-enabled` option enables experimental support for snap sync with IBFT/QBFT permissioned Bonsai-DB chains [#7140](https://github.com/hyperledger/besu/pull/7140)
 - Added EIP-7702 [#7237](https://github.com/hyperledger/besu/pull/7237)
 
 ### Bug fixes
diff --git a/besu/src/main/java/org/hyperledger/besu/cli/BesuCommand.java b/besu/src/main/java/org/hyperledger/besu/cli/BesuCommand.java
index 7e1be15fb65..12752f2e9a1 100644
--- a/besu/src/main/java/org/hyperledger/besu/cli/BesuCommand.java
+++ b/besu/src/main/java/org/hyperledger/besu/cli/BesuCommand.java
@@ -1552,10 +1552,11 @@ private void validateOptions() {
   }
 
   private void validateConsensusSyncCompatibilityOptions() {
-    // snap and checkpoint can't be used with BFT but can for clique
-    if (genesisConfigOptionsSupplier.get().isIbftLegacy()
-        || genesisConfigOptionsSupplier.get().isIbft2()
-        || genesisConfigOptionsSupplier.get().isQbft()) {
+    // snap and checkpoint are experimental for BFT
+    if ((genesisConfigOptionsSupplier.get().isIbftLegacy()
+            || genesisConfigOptionsSupplier.get().isIbft2()
+            || genesisConfigOptionsSupplier.get().isQbft())
+        && !unstableSynchronizerOptions.isSnapSyncBftEnabled()) {
       final String errorSuffix = "can't be used with BFT networks";
       if (SyncMode.CHECKPOINT.equals(syncMode) || SyncMode.X_CHECKPOINT.equals(syncMode)) {
         throw new ParameterException(
@@ -2181,7 +2182,7 @@ private SynchronizerConfiguration buildSyncConfig() {
     return unstableSynchronizerOptions
         .toDomainObject()
         .syncMode(syncMode)
-        .fastSyncMinimumPeerCount(syncMinPeerCount)
+        .syncMinimumPeerCount(syncMinPeerCount)
         .build();
   }
 
@@ -2194,14 +2195,14 @@ private TransactionPoolConfiguration buildTransactionPoolConfiguration() {
             .saveFile((dataPath.resolve(txPoolConf.getSaveFile().getPath()).toFile()));
 
     if (genesisConfigOptionsSupplier.get().isZeroBaseFee()) {
-      logger.info(
+      logger.warn(
           "Forcing price bump for transaction replacement to 0, since we are on a zero basefee network");
       txPoolConfBuilder.priceBump(Percentage.ZERO);
     }
 
     if (miningParametersSupplier.get().getMinTransactionGasPrice().equals(Wei.ZERO)
         && !transactionPoolOptions.isPriceBumpSet(commandLine)) {
-      logger.info(
+      logger.warn(
           "Forcing price bump for transaction replacement to 0, since min-gas-price is set to 0");
       txPoolConfBuilder.priceBump(Percentage.ZERO);
     }
@@ -2810,6 +2811,7 @@ && getDataStorageConfiguration().getBonsaiLimitTrieLogsEnabled()) {
     }
 
     builder.setSnapServerEnabled(this.unstableSynchronizerOptions.isSnapsyncServerEnabled());
+    builder.setSnapSyncBftEnabled(this.unstableSynchronizerOptions.isSnapSyncBftEnabled());
 
     builder.setTxPoolImplementation(buildTransactionPoolConfiguration().getTxPoolImplementation());
     builder.setWorldStateUpdateMode(unstableEvmOptions.toDomainObject().worldUpdaterMode());
diff --git a/besu/src/main/java/org/hyperledger/besu/cli/ConfigurationOverviewBuilder.java b/besu/src/main/java/org/hyperledger/besu/cli/ConfigurationOverviewBuilder.java
index 2d74ae8d26f..b2f89a349e2 100644
--- a/besu/src/main/java/org/hyperledger/besu/cli/ConfigurationOverviewBuilder.java
+++ b/besu/src/main/java/org/hyperledger/besu/cli/ConfigurationOverviewBuilder.java
@@ -56,6 +56,7 @@ public class ConfigurationOverviewBuilder {
   private long trieLogRetentionLimit = 0;
   private Integer trieLogsPruningWindowSize = null;
   private boolean isSnapServerEnabled = false;
+  private boolean isSnapSyncBftEnabled = false;
   private TransactionPoolConfiguration.Implementation txPoolImplementation;
   private EvmConfiguration.WorldUpdaterMode worldStateUpdateMode;
   private Map<String, String> environment;
@@ -233,6 +234,17 @@ public ConfigurationOverviewBuilder setSnapServerEnabled(final boolean snapServe
     return this;
   }
 
+  /**
+   * Sets snap sync BFT enabled/disabled
+   *
+   * @param snapSyncBftEnabled bool to indicate if snap sync for BFT is enabled
+   * @return the builder
+   */
+  public ConfigurationOverviewBuilder setSnapSyncBftEnabled(final boolean snapSyncBftEnabled) {
+    isSnapSyncBftEnabled = snapSyncBftEnabled;
+    return this;
+  }
+
   /**
    * Sets trie logs pruning window size
    *
@@ -357,6 +369,10 @@ public String build() {
       lines.add("Experimental Snap Sync server enabled");
     }
 
+    if (isSnapSyncBftEnabled) {
+      lines.add("Experimental Snap Sync for BFT enabled");
+    }
+
     if (isBonsaiLimitTrieLogsEnabled) {
       final StringBuilder trieLogPruningString = new StringBuilder();
       trieLogPruningString
diff --git a/besu/src/main/java/org/hyperledger/besu/cli/options/unstable/SynchronizerOptions.java b/besu/src/main/java/org/hyperledger/besu/cli/options/unstable/SynchronizerOptions.java
index e52839cceb4..95bbe0a2b1f 100644
--- a/besu/src/main/java/org/hyperledger/besu/cli/options/unstable/SynchronizerOptions.java
+++ b/besu/src/main/java/org/hyperledger/besu/cli/options/unstable/SynchronizerOptions.java
@@ -85,6 +85,8 @@ public class SynchronizerOptions implements CLIOptions<SynchronizerConfiguration
 
   private static final String CHECKPOINT_POST_MERGE_FLAG = "--Xcheckpoint-post-merge-enabled";
 
+  private static final String SNAP_SYNC_BFT_ENABLED_FLAG = "--Xsnapsync-bft-enabled";
+
   /**
    * Parse block propagation range.
    *
@@ -304,6 +306,14 @@ public void parseBlockPropagationRange(final String arg) {
   private Boolean checkpointPostMergeSyncEnabled =
       SynchronizerConfiguration.DEFAULT_CHECKPOINT_POST_MERGE_ENABLED;
 
+  @CommandLine.Option(
+      names = SNAP_SYNC_BFT_ENABLED_FLAG,
+      hidden = true,
+      paramLabel = "<Boolean>",
+      arity = "0..1",
+      description = "Snap sync enabled for BFT chains (default: ${DEFAULT-VALUE})")
+  private Boolean snapsyncBftEnabled = SnapSyncConfiguration.DEFAULT_SNAP_SYNC_BFT_ENABLED;
+
   private SynchronizerOptions() {}
 
   /**
@@ -315,6 +325,15 @@ public boolean isSnapsyncServerEnabled() {
     return snapsyncServerEnabled;
   }
 
+  /**
+   * Flag to know whether the Snap sync should be enabled for a BFT chain
+   *
+   * @return true if snap sync for BFT is enabled
+   */
+  public boolean isSnapSyncBftEnabled() {
+    return snapsyncBftEnabled;
+  }
+
   /**
    * Create synchronizer options.
    *
@@ -342,7 +361,7 @@ public static SynchronizerOptions fromConfig(final SynchronizerConfiguration con
     options.downloaderParallelism = config.getDownloaderParallelism();
     options.transactionsParallelism = config.getTransactionsParallelism();
     options.computationParallelism = config.getComputationParallelism();
-    options.fastSyncPivotDistance = config.getFastSyncPivotDistance();
+    options.fastSyncPivotDistance = config.getSyncPivotDistance();
     options.fastSyncFullValidationRate = config.getFastSyncFullValidationRate();
     options.worldStateHashCountPerRequest = config.getWorldStateHashCountPerRequest();
     options.worldStateRequestParallelism = config.getWorldStateRequestParallelism();
@@ -365,6 +384,7 @@ public static SynchronizerOptions fromConfig(final SynchronizerConfiguration con
         config.getSnapSyncConfiguration().getLocalFlatStorageCountToHealPerRequest();
     options.checkpointPostMergeSyncEnabled = config.isCheckpointPostMergeEnabled();
     options.snapsyncServerEnabled = config.getSnapSyncConfiguration().isSnapServerEnabled();
+    options.snapsyncBftEnabled = config.getSnapSyncConfiguration().isSnapSyncBftEnabled();
     return options;
   }
 
@@ -380,7 +400,7 @@ public SynchronizerConfiguration.Builder toDomainObject() {
     builder.downloaderParallelism(downloaderParallelism);
     builder.transactionsParallelism(transactionsParallelism);
     builder.computationParallelism(computationParallelism);
-    builder.fastSyncPivotDistance(fastSyncPivotDistance);
+    builder.syncPivotDistance(fastSyncPivotDistance);
     builder.fastSyncFullValidationRate(fastSyncFullValidationRate);
     builder.worldStateHashCountPerRequest(worldStateHashCountPerRequest);
     builder.worldStateRequestParallelism(worldStateRequestParallelism);
@@ -397,6 +417,7 @@ public SynchronizerConfiguration.Builder toDomainObject() {
             .localFlatAccountCountToHealPerRequest(snapsyncFlatAccountHealedCountPerRequest)
             .localFlatStorageCountToHealPerRequest(snapsyncFlatStorageHealedCountPerRequest)
             .isSnapServerEnabled(snapsyncServerEnabled)
+            .isSnapSyncBftEnabled(snapsyncBftEnabled)
             .build());
     builder.checkpointPostMergeEnabled(checkpointPostMergeSyncEnabled);
 
@@ -454,7 +475,9 @@ public List<String> getCLIOptions() {
             SNAP_FLAT_STORAGE_HEALED_COUNT_PER_REQUEST_FLAG,
             OptionParser.format(snapsyncFlatStorageHealedCountPerRequest),
             SNAP_SERVER_ENABLED_FLAG,
-            OptionParser.format(snapsyncServerEnabled));
+            OptionParser.format(snapsyncServerEnabled),
+            SNAP_SYNC_BFT_ENABLED_FLAG,
+            OptionParser.format(snapsyncBftEnabled));
     return value;
   }
 }
diff --git a/besu/src/main/java/org/hyperledger/besu/controller/BesuControllerBuilder.java b/besu/src/main/java/org/hyperledger/besu/controller/BesuControllerBuilder.java
index aab0000592f..ac0fa25fd30 100644
--- a/besu/src/main/java/org/hyperledger/besu/controller/BesuControllerBuilder.java
+++ b/besu/src/main/java/org/hyperledger/besu/controller/BesuControllerBuilder.java
@@ -22,6 +22,7 @@
 import org.hyperledger.besu.config.GenesisConfigOptions;
 import org.hyperledger.besu.consensus.merge.MergeContext;
 import org.hyperledger.besu.consensus.merge.UnverifiedForkchoiceSupplier;
+import org.hyperledger.besu.consensus.qbft.BFTPivotSelectorFromPeers;
 import org.hyperledger.besu.consensus.qbft.pki.PkiBlockCreationConfiguration;
 import org.hyperledger.besu.cryptoservices.NodeKey;
 import org.hyperledger.besu.datatypes.Hash;
@@ -106,6 +107,7 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Optional;
 import java.util.OptionalLong;
@@ -683,7 +685,7 @@ public BesuController build() {
 
     final PivotBlockSelector pivotBlockSelector =
         createPivotSelector(
-            protocolSchedule, protocolContext, ethContext, syncState, metricsSystem);
+            protocolSchedule, protocolContext, ethContext, syncState, metricsSystem, blockchain);
 
     final Synchronizer synchronizer =
         createSynchronizer(
@@ -837,9 +839,22 @@ private PivotBlockSelector createPivotSelector(
       final ProtocolContext protocolContext,
       final EthContext ethContext,
       final SyncState syncState,
-      final MetricsSystem metricsSystem) {
+      final MetricsSystem metricsSystem,
+      final Blockchain blockchain) {
 
-    if (genesisConfigOptions.getTerminalTotalDifficulty().isPresent()) {
+    if (genesisConfigOptions.isQbft() || genesisConfigOptions.isIbft2()) {
+      LOG.info(
+          "{} is configured, creating initial sync for BFT",
+          genesisConfigOptions.getConsensusEngine().toUpperCase(Locale.ROOT));
+      return new BFTPivotSelectorFromPeers(
+          ethContext,
+          syncConfig,
+          syncState,
+          metricsSystem,
+          protocolContext,
+          nodeKey,
+          blockchain.getChainHeadHeader());
+    } else if (genesisConfigOptions.getTerminalTotalDifficulty().isPresent()) {
       LOG.info("TTD difficulty is present, creating initial sync for PoS");
 
       final MergeContext mergeContext = protocolContext.getConsensusContext(MergeContext.class);
diff --git a/besu/src/test/java/org/hyperledger/besu/RunnerTest.java b/besu/src/test/java/org/hyperledger/besu/RunnerTest.java
index f6c6aac5f2f..e10d5475818 100644
--- a/besu/src/test/java/org/hyperledger/besu/RunnerTest.java
+++ b/besu/src/test/java/org/hyperledger/besu/RunnerTest.java
@@ -225,8 +225,8 @@ private void syncFromGenesis(final SyncMode mode, final GenesisConfigFile genesi
       final SynchronizerConfiguration syncConfigBehind =
           SynchronizerConfiguration.builder()
               .syncMode(mode)
-              .fastSyncPivotDistance(5)
-              .fastSyncMinimumPeerCount(1)
+              .syncPivotDistance(5)
+              .syncMinimumPeerCount(1)
               .build();
       final Path dataDirBehind = Files.createTempDirectory(temp, "db-behind");
 
diff --git a/besu/src/test/java/org/hyperledger/besu/cli/BesuCommandTest.java b/besu/src/test/java/org/hyperledger/besu/cli/BesuCommandTest.java
index 2c17cc42c9a..641e69dba64 100644
--- a/besu/src/test/java/org/hyperledger/besu/cli/BesuCommandTest.java
+++ b/besu/src/test/java/org/hyperledger/besu/cli/BesuCommandTest.java
@@ -1167,7 +1167,7 @@ public void checkValidDefaultFastSyncMinPeers() {
 
     final SynchronizerConfiguration syncConfig = syncConfigurationCaptor.getValue();
     assertThat(syncConfig.getSyncMode()).isEqualTo(SyncMode.FAST);
-    assertThat(syncConfig.getFastSyncMinimumPeerCount()).isEqualTo(5);
+    assertThat(syncConfig.getSyncMinimumPeerCount()).isEqualTo(5);
     assertThat(commandOutput.toString(UTF_8)).isEmpty();
     assertThat(commandErrorOutput.toString(UTF_8)).isEmpty();
   }
@@ -1179,7 +1179,7 @@ public void parsesValidFastSyncMinPeersOption() {
 
     final SynchronizerConfiguration syncConfig = syncConfigurationCaptor.getValue();
     assertThat(syncConfig.getSyncMode()).isEqualTo(SyncMode.FAST);
-    assertThat(syncConfig.getFastSyncMinimumPeerCount()).isEqualTo(11);
+    assertThat(syncConfig.getSyncMinimumPeerCount()).isEqualTo(11);
     assertThat(commandOutput.toString(UTF_8)).isEmpty();
     assertThat(commandErrorOutput.toString(UTF_8)).isEmpty();
   }
@@ -1191,7 +1191,7 @@ public void parsesValidSnapSyncMinPeersOption() {
 
     final SynchronizerConfiguration syncConfig = syncConfigurationCaptor.getValue();
     assertThat(syncConfig.getSyncMode()).isEqualTo(SyncMode.SNAP);
-    assertThat(syncConfig.getFastSyncMinimumPeerCount()).isEqualTo(11);
+    assertThat(syncConfig.getSyncMinimumPeerCount()).isEqualTo(11);
     assertThat(commandOutput.toString(UTF_8)).isEmpty();
     assertThat(commandErrorOutput.toString(UTF_8)).isEmpty();
   }
@@ -1203,7 +1203,7 @@ public void parsesValidSyncMinPeersOption() {
 
     final SynchronizerConfiguration syncConfig = syncConfigurationCaptor.getValue();
     assertThat(syncConfig.getSyncMode()).isEqualTo(SyncMode.FAST);
-    assertThat(syncConfig.getFastSyncMinimumPeerCount()).isEqualTo(11);
+    assertThat(syncConfig.getSyncMinimumPeerCount()).isEqualTo(11);
     assertThat(commandOutput.toString(UTF_8)).isEmpty();
     assertThat(commandErrorOutput.toString(UTF_8)).isEmpty();
   }
diff --git a/besu/src/test/java/org/hyperledger/besu/cli/CascadingDefaultProviderTest.java b/besu/src/test/java/org/hyperledger/besu/cli/CascadingDefaultProviderTest.java
index c2e26344a0b..4cdd8163d95 100644
--- a/besu/src/test/java/org/hyperledger/besu/cli/CascadingDefaultProviderTest.java
+++ b/besu/src/test/java/org/hyperledger/besu/cli/CascadingDefaultProviderTest.java
@@ -138,7 +138,7 @@ public void overrideDefaultValuesIfKeyIsPresentInConfigFile(final @TempDir File
     verify(mockControllerBuilder).synchronizerConfiguration(syncConfigurationCaptor.capture());
 
     assertThat(syncConfigurationCaptor.getValue().getSyncMode()).isEqualTo(SyncMode.FAST);
-    assertThat(syncConfigurationCaptor.getValue().getFastSyncMinimumPeerCount()).isEqualTo(13);
+    assertThat(syncConfigurationCaptor.getValue().getSyncMinimumPeerCount()).isEqualTo(13);
 
     assertThat(commandOutput.toString(UTF_8)).isEmpty();
     assertThat(commandErrorOutput.toString(UTF_8)).isEmpty();
@@ -182,7 +182,7 @@ public void noOverrideDefaultValuesIfKeyIsNotPresentInConfigFile() {
 
     final SynchronizerConfiguration syncConfig = syncConfigurationCaptor.getValue();
     assertThat(syncConfig.getSyncMode()).isEqualTo(SyncMode.SNAP);
-    assertThat(syncConfig.getFastSyncMinimumPeerCount()).isEqualTo(5);
+    assertThat(syncConfig.getSyncMinimumPeerCount()).isEqualTo(5);
 
     assertThat(commandOutput.toString(UTF_8)).isEmpty();
     assertThat(commandErrorOutput.toString(UTF_8)).isEmpty();
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 3dcd38809e4..0511279c19f 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
@@ -38,9 +38,9 @@ protected SynchronizerConfiguration.Builder createDefaultDomainObject() {
   @Override
   protected SynchronizerConfiguration.Builder createCustomizedDomainObject() {
     return SynchronizerConfiguration.builder()
-        .fastSyncPivotDistance(SynchronizerConfiguration.DEFAULT_PIVOT_DISTANCE_FROM_HEAD + 10)
+        .syncPivotDistance(SynchronizerConfiguration.DEFAULT_PIVOT_DISTANCE_FROM_HEAD + 10)
         .fastSyncFullValidationRate(SynchronizerConfiguration.DEFAULT_FULL_VALIDATION_RATE / 2)
-        .fastSyncMinimumPeerCount(SynchronizerConfiguration.DEFAULT_FAST_SYNC_MINIMUM_PEERS + 2)
+        .syncMinimumPeerCount(SynchronizerConfiguration.DEFAULT_SYNC_MINIMUM_PEERS + 2)
         .worldStateHashCountPerRequest(
             SynchronizerConfiguration.DEFAULT_WORLD_STATE_HASH_COUNT_PER_REQUEST + 2)
         .worldStateRequestParallelism(
@@ -94,7 +94,7 @@ protected SynchronizerOptions getOptionsFromBesuCommand(final TestBesuCommand be
 
   @Override
   protected List<String> getFieldsToIgnore() {
-    return Arrays.asList("fastSyncMinimumPeerCount");
+    return Arrays.asList("syncMinimumPeerCount");
   }
 
   @Override
diff --git a/consensus/common/src/main/java/org/hyperledger/besu/consensus/common/bft/BftEventQueue.java b/consensus/common/src/main/java/org/hyperledger/besu/consensus/common/bft/BftEventQueue.java
index a4f2faff788..4221fd1fac7 100644
--- a/consensus/common/src/main/java/org/hyperledger/besu/consensus/common/bft/BftEventQueue.java
+++ b/consensus/common/src/main/java/org/hyperledger/besu/consensus/common/bft/BftEventQueue.java
@@ -15,10 +15,12 @@
 package org.hyperledger.besu.consensus.common.bft;
 
 import org.hyperledger.besu.consensus.common.bft.events.BftEvent;
+import org.hyperledger.besu.consensus.common.bft.events.BftEvents;
 
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import javax.annotation.Nullable;
 
 import org.slf4j.Logger;
@@ -30,6 +32,7 @@ public class BftEventQueue {
 
   private static final Logger LOG = LoggerFactory.getLogger(BftEventQueue.class);
   private final int messageQueueLimit;
+  private final AtomicBoolean started = new AtomicBoolean(false);
 
   /**
    * Instantiates a new Bft event queue.
@@ -40,16 +43,30 @@ public BftEventQueue(final int messageQueueLimit) {
     this.messageQueueLimit = messageQueueLimit;
   }
 
+  /** Start the event queue. Until it has been started no events will be queued for processing. */
+  public void start() {
+    started.set(true);
+  }
+
+  private boolean isStarted() {
+    return started.get();
+  }
+
   /**
-   * Put an Bft event onto the queue
+   * Put an Bft event onto the queue. Note: the event queue must be started before an event will be
+   * queued for processing. Events received before the queue is started will be discarded.
    *
    * @param event Provided bft event
    */
   public void add(final BftEvent event) {
-    if (queue.size() > messageQueueLimit) {
-      LOG.warn("Queue size exceeded trying to add new bft event {}", event);
-    } else {
-      queue.add(event);
+
+    // Don't queue events other than block timer expiry, until we know we can process them
+    if (isStarted() || event.getType() == BftEvents.Type.BLOCK_TIMER_EXPIRY) {
+      if (queue.size() > messageQueueLimit) {
+        LOG.warn("Queue size exceeded trying to add new bft event {}", event);
+      } else {
+        queue.add(event);
+      }
     }
   }
 
diff --git a/consensus/common/src/main/java/org/hyperledger/besu/consensus/common/bft/BftProcessor.java b/consensus/common/src/main/java/org/hyperledger/besu/consensus/common/bft/BftProcessor.java
index efd75532f94..93df77ea778 100644
--- a/consensus/common/src/main/java/org/hyperledger/besu/consensus/common/bft/BftProcessor.java
+++ b/consensus/common/src/main/java/org/hyperledger/besu/consensus/common/bft/BftProcessor.java
@@ -61,6 +61,9 @@ public void awaitStop() throws InterruptedException {
   @Override
   public void run() {
     try {
+      // Start the event queue. Until it is started it won't accept new events from peers
+      incomingQueue.start();
+
       while (!shutdown) {
         nextEvent().ifPresent(eventMultiplexer::handleBftEvent);
       }
diff --git a/consensus/common/src/main/java/org/hyperledger/besu/consensus/common/validator/ValidatorProvider.java b/consensus/common/src/main/java/org/hyperledger/besu/consensus/common/validator/ValidatorProvider.java
index f11902baef8..05ddcd00ab4 100644
--- a/consensus/common/src/main/java/org/hyperledger/besu/consensus/common/validator/ValidatorProvider.java
+++ b/consensus/common/src/main/java/org/hyperledger/besu/consensus/common/validator/ValidatorProvider.java
@@ -14,8 +14,10 @@
  */
 package org.hyperledger.besu.consensus.common.validator;
 
+import org.hyperledger.besu.cryptoservices.NodeKey;
 import org.hyperledger.besu.datatypes.Address;
 import org.hyperledger.besu.ethereum.core.BlockHeader;
+import org.hyperledger.besu.ethereum.core.Util;
 
 import java.util.Collection;
 import java.util.Optional;
@@ -67,4 +69,14 @@ public interface ValidatorProvider {
   default Optional<VoteProvider> getVoteProviderAfterBlock(final BlockHeader header) {
     return getVoteProviderAtHead();
   }
+
+  /**
+   * Determines if this node is a validator
+   *
+   * @param nodekey our node key
+   * @return true if this node is a validator
+   */
+  default boolean nodeIsValidator(final NodeKey nodekey) {
+    return this.getValidatorsAtHead().contains(Util.publicKeyToAddress(nodekey.getPublicKey()));
+  }
 }
diff --git a/consensus/common/src/test/java/org/hyperledger/besu/consensus/common/bft/BftEventQueueTest.java b/consensus/common/src/test/java/org/hyperledger/besu/consensus/common/bft/BftEventQueueTest.java
index db5587b9d28..b39bef3a439 100644
--- a/consensus/common/src/test/java/org/hyperledger/besu/consensus/common/bft/BftEventQueueTest.java
+++ b/consensus/common/src/test/java/org/hyperledger/besu/consensus/common/bft/BftEventQueueTest.java
@@ -32,23 +32,53 @@ public class BftEventQueueTest {
   private static class DummyBftEvent implements BftEvent {
     @Override
     public BftEvents.Type getType() {
-      return null;
+      return BftEvents.Type.MESSAGE;
+    }
+  }
+
+  private static class DummyRoundExpiryBftEvent implements BftEvent {
+    @Override
+    public BftEvents.Type getType() {
+      return BftEvents.Type.ROUND_EXPIRY;
+    }
+  }
+
+  private static class DummyNewChainHeadBftEvent implements BftEvent {
+    @Override
+    public BftEvents.Type getType() {
+      return BftEvents.Type.NEW_CHAIN_HEAD;
+    }
+  }
+
+  private static class DummyBlockTimerExpiryBftEvent implements BftEvent {
+    @Override
+    public BftEvents.Type getType() {
+      return BftEvents.Type.BLOCK_TIMER_EXPIRY;
     }
   }
 
   @Test
   public void addPoll() throws InterruptedException {
     final BftEventQueue queue = new BftEventQueue(MAX_QUEUE_SIZE);
+    queue.start();
 
     assertThat(queue.poll(0, TimeUnit.MICROSECONDS)).isNull();
-    final DummyBftEvent dummyEvent = new DummyBftEvent();
-    queue.add(dummyEvent);
-    assertThat(queue.poll(0, TimeUnit.MICROSECONDS)).isEqualTo(dummyEvent);
+    final DummyBftEvent dummyMessageEvent = new DummyBftEvent();
+    final DummyRoundExpiryBftEvent dummyRoundTimerEvent = new DummyRoundExpiryBftEvent();
+    final DummyNewChainHeadBftEvent dummyNewChainHeadEvent = new DummyNewChainHeadBftEvent();
+    queue.add(dummyMessageEvent);
+    queue.add(dummyRoundTimerEvent);
+    queue.add(dummyNewChainHeadEvent);
+    assertThat(queue.poll(0, TimeUnit.MICROSECONDS)).isEqualTo(dummyMessageEvent);
+    assertThat(queue.poll(0, TimeUnit.MICROSECONDS)).isEqualTo(dummyRoundTimerEvent);
+    assertThat(queue.poll(0, TimeUnit.MICROSECONDS)).isEqualTo(dummyNewChainHeadEvent);
+    assertThat(queue.poll(0, TimeUnit.MICROSECONDS)).isNull();
   }
 
   @Test
   public void queueOrdering() throws InterruptedException {
     final BftEventQueue queue = new BftEventQueue(MAX_QUEUE_SIZE);
+    queue.start();
 
     final DummyBftEvent dummyEvent1 = new DummyBftEvent();
     final DummyBftEvent dummyEvent2 = new DummyBftEvent();
@@ -69,6 +99,7 @@ public void queueOrdering() throws InterruptedException {
   @Test
   public void addSizeLimit() throws InterruptedException {
     final BftEventQueue queue = new BftEventQueue(MAX_QUEUE_SIZE);
+    queue.start();
 
     for (int i = 0; i <= 1000; i++) {
       final DummyBftEvent dummyEvent = new DummyBftEvent();
@@ -85,4 +116,34 @@ public void addSizeLimit() throws InterruptedException {
     assertThat(drain).doesNotContainNull();
     assertThat(queue.poll(0, TimeUnit.MICROSECONDS)).isNull();
   }
+
+  @Test
+  public void doNotAddUntilStarted() throws InterruptedException {
+    final BftEventQueue queue = new BftEventQueue(MAX_QUEUE_SIZE);
+
+    assertThat(queue.poll(0, TimeUnit.MICROSECONDS)).isNull();
+    final DummyBftEvent dummyMessageEvent = new DummyBftEvent();
+    final DummyRoundExpiryBftEvent dummyRoundTimerEvent = new DummyRoundExpiryBftEvent();
+    final DummyNewChainHeadBftEvent dummyNewChainHeadEvent = new DummyNewChainHeadBftEvent();
+
+    // BFT event queue needs starting before it will queue up most types of event. This prevents
+    // the queue filling with irrelevant messages until BFT mining has started
+    queue.add(dummyMessageEvent);
+    queue.add(dummyRoundTimerEvent);
+    queue.add(dummyNewChainHeadEvent);
+    assertThat(queue.poll(0, TimeUnit.MICROSECONDS)).isNull();
+  }
+
+  @Test
+  public void alwaysAddBlockTimerExpiryEvents() throws InterruptedException {
+    final BftEventQueue queue = new BftEventQueue(MAX_QUEUE_SIZE);
+
+    assertThat(queue.poll(0, TimeUnit.MICROSECONDS)).isNull();
+    final DummyBlockTimerExpiryBftEvent dummyBlockTimerEvent = new DummyBlockTimerExpiryBftEvent();
+
+    // Block expiry events need processing in order for the mining coordinator to start,
+    // so those should be handled regardless of whether the queue has been started
+    queue.add(dummyBlockTimerEvent);
+    assertThat(queue.poll(0, TimeUnit.MICROSECONDS)).isEqualTo(dummyBlockTimerEvent);
+  }
 }
diff --git a/consensus/common/src/test/java/org/hyperledger/besu/consensus/common/bft/BftProcessorTest.java b/consensus/common/src/test/java/org/hyperledger/besu/consensus/common/bft/BftProcessorTest.java
index 5ff31b538bc..5c8d86f3866 100644
--- a/consensus/common/src/test/java/org/hyperledger/besu/consensus/common/bft/BftProcessorTest.java
+++ b/consensus/common/src/test/java/org/hyperledger/besu/consensus/common/bft/BftProcessorTest.java
@@ -130,6 +130,7 @@ public void handlesQueueInterruptGracefully() throws InterruptedException {
   @Test
   public void drainEventsIntoStateMachine() throws InterruptedException {
     final BftEventQueue queue = new BftEventQueue(1000);
+    queue.start();
     final BftProcessor processor = new BftProcessor(queue, mockeEventMultiplexer);
 
     // Start the BftProcessor
diff --git a/consensus/common/src/test/java/org/hyperledger/besu/consensus/common/bft/RoundTimerTest.java b/consensus/common/src/test/java/org/hyperledger/besu/consensus/common/bft/RoundTimerTest.java
index f8a061471db..0ebca51c9e2 100644
--- a/consensus/common/src/test/java/org/hyperledger/besu/consensus/common/bft/RoundTimerTest.java
+++ b/consensus/common/src/test/java/org/hyperledger/besu/consensus/common/bft/RoundTimerTest.java
@@ -45,6 +45,7 @@ public class RoundTimerTest {
   public void initialise() {
     bftExecutors = mock(BftExecutors.class);
     queue = new BftEventQueue(1000);
+    queue.start();
     timer = new RoundTimer(queue, 1, bftExecutors);
   }
 
diff --git a/consensus/common/src/test/java/org/hyperledger/besu/consensus/common/bft/blockcreation/BftMiningCoordinatorTest.java b/consensus/common/src/test/java/org/hyperledger/besu/consensus/common/bft/blockcreation/BftMiningCoordinatorTest.java
index f2618c1abd1..cb0dffba9b1 100644
--- a/consensus/common/src/test/java/org/hyperledger/besu/consensus/common/bft/blockcreation/BftMiningCoordinatorTest.java
+++ b/consensus/common/src/test/java/org/hyperledger/besu/consensus/common/bft/blockcreation/BftMiningCoordinatorTest.java
@@ -56,6 +56,7 @@ public class BftMiningCoordinatorTest {
 
   @BeforeEach
   public void setup() {
+    eventQueue.start();
     bftMiningCoordinator =
         new BftMiningCoordinator(
             bftExecutors, controller, bftProcessor, bftBlockCreatorFactory, blockChain, eventQueue);
diff --git a/consensus/qbft/src/main/java/org/hyperledger/besu/consensus/qbft/BFTPivotSelectorFromPeers.java b/consensus/qbft/src/main/java/org/hyperledger/besu/consensus/qbft/BFTPivotSelectorFromPeers.java
new file mode 100644
index 00000000000..7437b349a2a
--- /dev/null
+++ b/consensus/qbft/src/main/java/org/hyperledger/besu/consensus/qbft/BFTPivotSelectorFromPeers.java
@@ -0,0 +1,160 @@
+/*
+ * 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.consensus.qbft;
+
+import org.hyperledger.besu.consensus.common.bft.BftContext;
+import org.hyperledger.besu.consensus.common.validator.ValidatorProvider;
+import org.hyperledger.besu.cryptoservices.NodeKey;
+import org.hyperledger.besu.ethereum.ProtocolContext;
+import org.hyperledger.besu.ethereum.core.BlockHeader;
+import org.hyperledger.besu.ethereum.eth.manager.EthContext;
+import org.hyperledger.besu.ethereum.eth.manager.EthPeer;
+import org.hyperledger.besu.ethereum.eth.sync.SynchronizerConfiguration;
+import org.hyperledger.besu.ethereum.eth.sync.fastsync.FastSyncState;
+import org.hyperledger.besu.ethereum.eth.sync.fastsync.NoSyncRequiredException;
+import org.hyperledger.besu.ethereum.eth.sync.fastsync.PivotSelectorFromPeers;
+import org.hyperledger.besu.ethereum.eth.sync.state.SyncState;
+import org.hyperledger.besu.plugin.services.MetricsSystem;
+
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * This class is a BFT-specific implementatino of the pivot-block selection used for snap-sync. It
+ * makes some pragmatic decisions about cases specific to permissioned chains, e.g. when there is a
+ * single validator node at the start of a chain, or a brand new chain has all nodes at block 0. For
+ * other cases the behaviour is the same as public-chain pivot selection, namely that the best peer
+ * is asked for its candidate pivot block.
+ */
+public class BFTPivotSelectorFromPeers extends PivotSelectorFromPeers {
+
+  private static final Logger LOG = LoggerFactory.getLogger(BFTPivotSelectorFromPeers.class);
+
+  private final ProtocolContext protocolContext;
+  private final BlockHeader blockHeader;
+  private final NodeKey nodeKey;
+
+  /**
+   * Create a BFT-specific pivot selector
+   *
+   * @param ethContext the eth context
+   * @param syncConfig the sync config
+   * @param syncState the sync state
+   * @param metricsSystem the metrics
+   * @param protocolContext the protocol context
+   * @param nodeKey the node key
+   * @param blockHeader the block header
+   */
+  public BFTPivotSelectorFromPeers(
+      final EthContext ethContext,
+      final SynchronizerConfiguration syncConfig,
+      final SyncState syncState,
+      final MetricsSystem metricsSystem,
+      final ProtocolContext protocolContext,
+      final NodeKey nodeKey,
+      final BlockHeader blockHeader) {
+    super(ethContext, syncConfig, syncState, metricsSystem);
+    this.protocolContext = protocolContext;
+    this.blockHeader = blockHeader;
+    this.nodeKey = nodeKey;
+    LOG.info("Creating pivot block selector for BFT node");
+  }
+
+  /**
+   * Determine if our node is a BFT validator node
+   *
+   * @param validatorProvider the validator provider
+   * @return true if we are a validator
+   */
+  protected boolean weAreAValidator(final ValidatorProvider validatorProvider) {
+    return validatorProvider.nodeIsValidator(nodeKey);
+  }
+
+  @Override
+  public Optional<FastSyncState> selectNewPivotBlock() {
+
+    final BftContext bftContext = protocolContext.getConsensusContext(BftContext.class);
+    final ValidatorProvider validatorProvider = bftContext.getValidatorProvider();
+    // See if we have a best peer
+    Optional<EthPeer> bestPeer = selectBestPeer();
+
+    if (bestPeer.isPresent()) {
+      // For a recently created permissioned chain we can skip snap sync until we're past the
+      // pivot distance
+      if (bestPeer.get().chainState().getEstimatedHeight() <= syncConfig.getSyncPivotDistance()) {
+        LOG.info(
+            "Best peer for sync found but chain height hasn't reached minimum sync pivot distance {}, exiting sync process",
+            syncConfig.getSyncPivotDistance());
+        throw new NoSyncRequiredException();
+      }
+
+      return bestPeer.flatMap(this::fromBestPeer);
+    } else {
+      // Treat us being the only validator as a special case. We are the only node that can produce
+      // blocks so we won't wait to sync with a non-validator node that may or may not exist
+      if (weAreAValidator(validatorProvider)
+          && validatorProvider.getValidatorsAtHead().size() == 1) {
+        LOG.info("This node is the only BFT validator, exiting sync process");
+        throw new NoSyncRequiredException();
+      }
+
+      // Treat the case where we are at block 0 and don't yet have any validator peers with a chain
+      // height estimate as potentially a new QBFT chain. Check if any of the other peers have the
+      // same block hash as our genesis block.
+      if (blockHeader.getNumber() == 0) {
+        final AtomicInteger peerValidatorCount = new AtomicInteger();
+        final AtomicBoolean peerAtOurGenesisBlock = new AtomicBoolean();
+        ethContext
+            .getEthPeers()
+            .streamAllPeers()
+            .forEach(
+                peer -> {
+                  // If we are at block 0 and our block hash matches at least one of our peers we
+                  // assume we're all at block 0 and therefore won't try to snap sync.
+                  if (peer.chainState()
+                      .getBestBlock()
+                      .getHash()
+                      .equals(blockHeader.getBlockHash())) {
+                    peerAtOurGenesisBlock.set(true);
+                  }
+                  if (!peer.getConnection().isDisconnected()
+                      && validatorProvider
+                          .getValidatorsAtHead()
+                          .contains(peer.getConnection().getPeerInfo().getAddress())) {
+                    peerValidatorCount.getAndIncrement();
+                  }
+                });
+
+        if (weAreAValidator(validatorProvider)
+            && peerValidatorCount.get() >= syncConfig.getSyncMinimumPeerCount()
+            && peerAtOurGenesisBlock.get()) {
+          // We have sync-min-peers x validators connected, all of whom have no head estimate. We'll
+          // assume this is a new chain and skip waiting for any more peers to sync with. The worst
+          // case is this puts us into full sync mode.
+          LOG.info(
+              "Peered with {} validators but no best peer found to sync from and their current block hash matches our genesis block. Assuming new BFT chain, exiting snap-sync",
+              peerValidatorCount.get());
+          throw new NoSyncRequiredException();
+        }
+      }
+    }
+
+    return Optional.empty();
+  }
+}
diff --git a/consensus/qbft/src/test/java/org/hyperledger/besu/consensus/qbft/sync/QbftPivotSelectorTest.java b/consensus/qbft/src/test/java/org/hyperledger/besu/consensus/qbft/sync/QbftPivotSelectorTest.java
new file mode 100644
index 00000000000..2f3013ea714
--- /dev/null
+++ b/consensus/qbft/src/test/java/org/hyperledger/besu/consensus/qbft/sync/QbftPivotSelectorTest.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright ConsenSys AG.
+ *
+ * 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.consensus.qbft.sync;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
+import org.hyperledger.besu.consensus.common.bft.BftContext;
+import org.hyperledger.besu.consensus.common.validator.ValidatorProvider;
+import org.hyperledger.besu.consensus.qbft.BFTPivotSelectorFromPeers;
+import org.hyperledger.besu.cryptoservices.NodeKey;
+import org.hyperledger.besu.datatypes.Address;
+import org.hyperledger.besu.ethereum.ProtocolContext;
+import org.hyperledger.besu.ethereum.core.BlockHeader;
+import org.hyperledger.besu.ethereum.eth.manager.EthContext;
+import org.hyperledger.besu.ethereum.eth.manager.EthPeers;
+import org.hyperledger.besu.ethereum.eth.sync.SyncMode;
+import org.hyperledger.besu.ethereum.eth.sync.SynchronizerConfiguration;
+import org.hyperledger.besu.ethereum.eth.sync.fastsync.FastSyncState;
+import org.hyperledger.besu.ethereum.eth.sync.fastsync.NoSyncRequiredException;
+import org.hyperledger.besu.ethereum.eth.sync.state.SyncState;
+import org.hyperledger.besu.plugin.services.MetricsSystem;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+public class QbftPivotSelectorTest {
+  private final SynchronizerConfiguration.Builder syncConfigBuilder =
+      new SynchronizerConfiguration.Builder().syncMode(SyncMode.SNAP).syncMinimumPeerCount(1);
+  private final SynchronizerConfiguration syncConfig = syncConfigBuilder.build();
+  @Mock private NodeKey nodeKey;
+  @Mock private BlockHeader blockHeader;
+  @Mock private ProtocolContext protocolContext;
+  @Mock private BftContext bftContext;
+  @Mock private SyncState syncState;
+  @Mock private MetricsSystem metricsSystem;
+  @Mock private EthContext ethContext;
+  @Mock private EthPeers ethPeers;
+  @Mock private ValidatorProvider validatorProvider;
+
+  @BeforeEach
+  public void setUp() {
+    when(protocolContext.getConsensusContext(any())).thenReturn(bftContext);
+    when(bftContext.getValidatorProvider()).thenReturn(validatorProvider);
+  }
+
+  @Test
+  public void returnEmptySyncStateIfValidatorWithOtherValidatorsButNoPeers() {
+
+    // We're not the only validator so add some other ones
+    List<Address> validatorList = new ArrayList<>();
+    validatorList.add(Address.ZERO);
+    validatorList.add(Address.ZERO);
+    validatorList.add(Address.ZERO);
+
+    when(ethContext.getEthPeers()).thenReturn(ethPeers);
+    when(validatorProvider.nodeIsValidator(any())).thenReturn(true);
+    when(validatorProvider.getValidatorsAtHead()).thenReturn(validatorList);
+    BFTPivotSelectorFromPeers pivotSelector =
+        new BFTPivotSelectorFromPeers(
+            ethContext,
+            syncConfig,
+            syncState,
+            metricsSystem,
+            protocolContext,
+            nodeKey,
+            blockHeader);
+    Optional<FastSyncState> pivotState = pivotSelector.selectNewPivotBlock();
+    assertThat(pivotState.isEmpty()).isTrue();
+  }
+
+  @Test
+  @SuppressWarnings("unused")
+  public void returnNoSyncRequiredIfOnlyValidatorAndNoPeers() {
+
+    // We're the only validator so just put us in the list
+    List<Address> validatorList = new ArrayList<>();
+    validatorList.add(Address.ZERO);
+
+    when(ethContext.getEthPeers()).thenReturn(ethPeers);
+    when(validatorProvider.nodeIsValidator(any())).thenReturn(true);
+    when(validatorProvider.getValidatorsAtHead()).thenReturn(validatorList);
+    BFTPivotSelectorFromPeers pivotSelector =
+        new BFTPivotSelectorFromPeers(
+            ethContext,
+            syncConfig,
+            syncState,
+            metricsSystem,
+            protocolContext,
+            nodeKey,
+            blockHeader);
+
+    try {
+      Optional<FastSyncState> pivotState = pivotSelector.selectNewPivotBlock();
+      fail("Expected NoSyncRequiredException but none thrown");
+    } catch (NoSyncRequiredException e) {
+      // Ignore - just make sure we get here
+    }
+  }
+
+  @Test
+  public void returnEmptySyncStateIfNonValidatorWithNoBestPeer() {
+    when(ethContext.getEthPeers()).thenReturn(ethPeers);
+    when(validatorProvider.nodeIsValidator(any())).thenReturn(false);
+    BFTPivotSelectorFromPeers pivotSelector =
+        new BFTPivotSelectorFromPeers(
+            ethContext,
+            syncConfig,
+            syncState,
+            metricsSystem,
+            protocolContext,
+            nodeKey,
+            blockHeader);
+
+    Optional<FastSyncState> pivotState = pivotSelector.selectNewPivotBlock();
+    assertThat(pivotState.isEmpty()).isTrue();
+  }
+
+  @Test
+  public void returnEmptySyncStateIfValidatorAndNotAtGenesisAndOtherValidators() {
+    when(ethContext.getEthPeers()).thenReturn(ethPeers);
+    when(validatorProvider.nodeIsValidator(any())).thenReturn(false);
+    when(blockHeader.getNumber()).thenReturn(10L);
+    BFTPivotSelectorFromPeers pivotSelector =
+        new BFTPivotSelectorFromPeers(
+            ethContext,
+            syncConfig,
+            syncState,
+            metricsSystem,
+            protocolContext,
+            nodeKey,
+            blockHeader);
+
+    Optional<FastSyncState> pivotState = pivotSelector.selectNewPivotBlock();
+    assertThat(pivotState.isEmpty()).isTrue();
+  }
+}
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/trielog/TrieLogPruner.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/trielog/TrieLogPruner.java
index 4a5cc875110..6f347be0334 100644
--- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/trielog/TrieLogPruner.java
+++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/trielog/TrieLogPruner.java
@@ -99,7 +99,7 @@ private int preloadQueue() {
     }
   }
 
-  public void addToPruneQueue(final long blockNumber, final Hash blockHash) {
+  public synchronized void addToPruneQueue(final long blockNumber, final Hash blockHash) {
     LOG.atTrace()
         .setMessage("adding trie log to queue for later pruning blockNumber {}; blockHash {}")
         .addArgument(blockNumber)
@@ -108,7 +108,7 @@ public void addToPruneQueue(final long blockNumber, final Hash blockHash) {
     trieLogBlocksAndForksByDescendingBlockNumber.put(blockNumber, blockHash);
   }
 
-  public int pruneFromQueue() {
+  public synchronized int pruneFromQueue() {
     final long retainAboveThisBlock = blockchain.getChainHeadBlockNumber() - numBlocksToRetain;
     final Optional<Hash> finalized = blockchain.getFinalized();
     if (requireFinalizedBlock && finalized.isEmpty()) {
diff --git a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/manager/snap/SnapServer.java b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/manager/snap/SnapServer.java
index 49f725d825f..d6bfe900d9c 100644
--- a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/manager/snap/SnapServer.java
+++ b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/manager/snap/SnapServer.java
@@ -32,6 +32,7 @@
 import org.hyperledger.besu.ethereum.proof.WorldStateProofProvider;
 import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput;
 import org.hyperledger.besu.ethereum.trie.CompactEncoding;
+import org.hyperledger.besu.ethereum.trie.MerkleTrie;
 import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.BonsaiWorldStateProvider;
 import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
 import org.hyperledger.besu.ethereum.worldstate.FlatDbMode;
@@ -225,6 +226,9 @@ MessageData constructGetAccountRangeResponse(final MessageData message) {
         .addArgument(() -> asLogHash(range.endKeyHash()))
         .log();
     try {
+      if (range.worldStateRootHash().equals(Hash.EMPTY_TRIE_HASH)) {
+        return AccountRangeMessage.create(new HashMap<>(), List.of(MerkleTrie.EMPTY_TRIE_NODE));
+      }
       return worldStateStorageProvider
           .apply(range.worldStateRootHash())
           .map(
@@ -509,8 +513,11 @@ MessageData constructGetTrieNodesResponse(final MessageData message) {
                   // first element in paths is account
                   if (triePath.size() == 1) {
                     // if there is only one path, presume it should be compact encoded account path
-                    var optStorage =
-                        storage.getTrieNodeUnsafe(CompactEncoding.decode(triePath.get(0)));
+                    final Bytes location = CompactEncoding.decode(triePath.get(0));
+                    var optStorage = storage.getTrieNodeUnsafe(location);
+                    if (optStorage.isEmpty() && location.isEmpty()) {
+                      optStorage = Optional.of(MerkleTrie.EMPTY_TRIE_NODE);
+                    }
                     if (optStorage.isPresent()) {
                       if (!trieNodes.isEmpty()
                           && (sumListBytes(trieNodes) + optStorage.get().size() > maxResponseBytes
@@ -534,9 +541,12 @@ MessageData constructGetTrieNodesResponse(final MessageData message) {
 
                     List<Bytes> storagePaths = triePath.subList(1, triePath.size());
                     for (var path : storagePaths) {
+                      final Bytes location = CompactEncoding.decode(path);
                       var optStorage =
-                          storage.getTrieNodeUnsafe(
-                              Bytes.concatenate(accountPrefix, CompactEncoding.decode(path)));
+                          storage.getTrieNodeUnsafe(Bytes.concatenate(accountPrefix, location));
+                      if (optStorage.isEmpty() && location.isEmpty()) {
+                        optStorage = Optional.of(MerkleTrie.EMPTY_TRIE_NODE);
+                      }
                       if (optStorage.isPresent()) {
                         if (!trieNodes.isEmpty()
                             && sumListBytes(trieNodes) + optStorage.get().size()
diff --git a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/DefaultSynchronizer.java b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/DefaultSynchronizer.java
index af35898ac22..5e596576aa3 100644
--- a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/DefaultSynchronizer.java
+++ b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/DefaultSynchronizer.java
@@ -25,6 +25,7 @@
 import org.hyperledger.besu.ethereum.eth.sync.checkpointsync.CheckpointDownloaderFactory;
 import org.hyperledger.besu.ethereum.eth.sync.fastsync.FastSyncDownloader;
 import org.hyperledger.besu.ethereum.eth.sync.fastsync.FastSyncState;
+import org.hyperledger.besu.ethereum.eth.sync.fastsync.NoSyncRequiredState;
 import org.hyperledger.besu.ethereum.eth.sync.fastsync.worldstate.FastDownloaderFactory;
 import org.hyperledger.besu.ethereum.eth.sync.fullsync.FullSyncDownloader;
 import org.hyperledger.besu.ethereum.eth.sync.fullsync.SyncTerminationCondition;
@@ -242,16 +243,24 @@ private CompletableFuture<Void> handleSyncResult(final FastSyncState result) {
       // We've been shutdown which will have triggered the fast sync future to complete
       return CompletableFuture.completedFuture(null);
     }
-    fastSyncDownloader.ifPresent(FastSyncDownloader::deleteFastSyncState);
-    result
-        .getPivotBlockHeader()
-        .ifPresent(
-            blockHeader -> protocolContext.getWorldStateArchive().resetArchiveStateTo(blockHeader));
-    LOG.info(
-        "Sync completed successfully with pivot block {}",
-        result.getPivotBlockNumber().getAsLong());
-    pivotBlockSelector.close();
-    syncState.markInitialSyncPhaseAsDone();
+
+    if (result instanceof NoSyncRequiredState) {
+      LOG.info("Sync ended (no sync required)");
+      syncState.markInitialSyncPhaseAsDone();
+    } else {
+      fastSyncDownloader.ifPresent(FastSyncDownloader::deleteFastSyncState);
+      result
+          .getPivotBlockHeader()
+          .ifPresent(
+              blockHeader ->
+                  protocolContext.getWorldStateArchive().resetArchiveStateTo(blockHeader));
+      if (result.hasPivotBlockHash())
+        LOG.info(
+            "Sync completed successfully with pivot block {}",
+            result.getPivotBlockNumber().getAsLong());
+      pivotBlockSelector.close();
+      syncState.markInitialSyncPhaseAsDone();
+    }
 
     if (terminationCondition.shouldContinueDownload()) {
       return startFullSync();
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 28f8bee6db7..d46da85dc48 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
@@ -29,7 +29,7 @@ public class SynchronizerConfiguration {
 
   public static final int DEFAULT_PIVOT_DISTANCE_FROM_HEAD = 50;
   public static final float DEFAULT_FULL_VALIDATION_RATE = .1f;
-  public static final int DEFAULT_FAST_SYNC_MINIMUM_PEERS = 5;
+  public static final int DEFAULT_SYNC_MINIMUM_PEERS = 5;
   public static final int DEFAULT_WORLD_STATE_HASH_COUNT_PER_REQUEST = 384;
   public static final int DEFAULT_WORLD_STATE_REQUEST_PARALLELISM = 10;
   public static final int DEFAULT_WORLD_STATE_MAX_REQUESTS_WITHOUT_PROGRESS = 1000;
@@ -53,9 +53,9 @@ public class SynchronizerConfiguration {
   public static final boolean DEFAULT_CHECKPOINT_POST_MERGE_ENABLED = false;
 
   // Fast sync config
-  private final int fastSyncPivotDistance;
+  private final int syncPivotDistance;
   private final float fastSyncFullValidationRate;
-  private final int fastSyncMinimumPeerCount;
+  private final int syncMinimumPeerCount;
   private final int worldStateHashCountPerRequest;
   private final int worldStateRequestParallelism;
   private final int worldStateMaxRequestsWithoutProgress;
@@ -87,9 +87,9 @@ public class SynchronizerConfiguration {
   private final long propagationManagerGetBlockTimeoutMillis;
 
   private SynchronizerConfiguration(
-      final int fastSyncPivotDistance,
+      final int syncPivotDistance,
       final float fastSyncFullValidationRate,
-      final int fastSyncMinimumPeerCount,
+      final int syncMinimumPeerCount,
       final int worldStateHashCountPerRequest,
       final int worldStateRequestParallelism,
       final int worldStateMaxRequestsWithoutProgress,
@@ -109,9 +109,9 @@ private SynchronizerConfiguration(
       final int maxTrailingPeers,
       final long propagationManagerGetBlockTimeoutMillis,
       final boolean checkpointPostMergeEnabled) {
-    this.fastSyncPivotDistance = fastSyncPivotDistance;
+    this.syncPivotDistance = syncPivotDistance;
     this.fastSyncFullValidationRate = fastSyncFullValidationRate;
-    this.fastSyncMinimumPeerCount = fastSyncMinimumPeerCount;
+    this.syncMinimumPeerCount = syncMinimumPeerCount;
     this.worldStateHashCountPerRequest = worldStateHashCountPerRequest;
     this.worldStateRequestParallelism = worldStateRequestParallelism;
     this.worldStateMaxRequestsWithoutProgress = worldStateMaxRequestsWithoutProgress;
@@ -171,12 +171,14 @@ public Range<Long> getBlockPropagationRange() {
   }
 
   /**
-   * The distance from the chain head at which we should switch from fast sync to full sync.
+   * The distance from the chain head at which we should switch from fast, snap, or checkpoint sync
+   * to full sync.
    *
-   * @return distance from the chain head at which we should switch from fast sync to full sync.
+   * @return distance from the chain head at which we should switch from fast, snap or checkpoint
+   *     sync to full sync.
    */
-  public int getFastSyncPivotDistance() {
-    return fastSyncPivotDistance;
+  public int getSyncPivotDistance() {
+    return syncPivotDistance;
   }
 
   public long getDownloaderChangeTargetThresholdByHeight() {
@@ -222,8 +224,8 @@ public float getFastSyncFullValidationRate() {
     return fastSyncFullValidationRate;
   }
 
-  public int getFastSyncMinimumPeerCount() {
-    return fastSyncMinimumPeerCount;
+  public int getSyncMinimumPeerCount() {
+    return syncMinimumPeerCount;
   }
 
   public int getWorldStateHashCountPerRequest() {
@@ -256,7 +258,7 @@ public long getPropagationManagerGetBlockTimeoutMillis() {
 
   public static class Builder {
     private SyncMode syncMode = SyncMode.FULL;
-    private int fastSyncMinimumPeerCount = DEFAULT_FAST_SYNC_MINIMUM_PEERS;
+    private int syncMinimumPeerCount = DEFAULT_SYNC_MINIMUM_PEERS;
     private int maxTrailingPeers = Integer.MAX_VALUE;
     private Range<Long> blockPropagationRange = DEFAULT_BLOCK_PROPAGATION_RANGE;
     private long downloaderChangeTargetThresholdByHeight =
@@ -270,7 +272,7 @@ public static class Builder {
     private int downloaderParallelism = DEFAULT_DOWNLOADER_PARALLELISM;
     private int transactionsParallelism = DEFAULT_TRANSACTIONS_PARALLELISM;
     private int computationParallelism = DEFAULT_COMPUTATION_PARALLELISM;
-    private int fastSyncPivotDistance = DEFAULT_PIVOT_DISTANCE_FROM_HEAD;
+    private int syncPivotDistance = DEFAULT_PIVOT_DISTANCE_FROM_HEAD;
     private float fastSyncFullValidationRate = DEFAULT_FULL_VALIDATION_RATE;
     private int worldStateHashCountPerRequest = DEFAULT_WORLD_STATE_HASH_COUNT_PER_REQUEST;
     private int worldStateRequestParallelism = DEFAULT_WORLD_STATE_REQUEST_PARALLELISM;
@@ -283,8 +285,8 @@ public static class Builder {
         DEFAULT_PROPAGATION_MANAGER_GET_BLOCK_TIMEOUT_MILLIS;
     private boolean checkpointPostMergeEnabled = DEFAULT_CHECKPOINT_POST_MERGE_ENABLED;
 
-    public Builder fastSyncPivotDistance(final int distance) {
-      fastSyncPivotDistance = distance;
+    public Builder syncPivotDistance(final int distance) {
+      syncPivotDistance = distance;
       return this;
     }
 
@@ -357,8 +359,8 @@ public Builder computationParallelism(final int computationParallelism) {
       return this;
     }
 
-    public Builder fastSyncMinimumPeerCount(final int fastSyncMinimumPeerCount) {
-      this.fastSyncMinimumPeerCount = fastSyncMinimumPeerCount;
+    public Builder syncMinimumPeerCount(final int syncMinimumPeerCount) {
+      this.syncMinimumPeerCount = syncMinimumPeerCount;
       return this;
     }
 
@@ -406,9 +408,9 @@ public Builder checkpointPostMergeEnabled(final boolean checkpointPostMergeEnabl
 
     public SynchronizerConfiguration build() {
       return new SynchronizerConfiguration(
-          fastSyncPivotDistance,
+          syncPivotDistance,
           fastSyncFullValidationRate,
-          fastSyncMinimumPeerCount,
+          syncMinimumPeerCount,
           worldStateHashCountPerRequest,
           worldStateRequestParallelism,
           worldStateMaxRequestsWithoutProgress,
diff --git a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/FastSyncActions.java b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/FastSyncActions.java
index 52d384acf6e..06bf8aace6a 100644
--- a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/FastSyncActions.java
+++ b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/FastSyncActions.java
@@ -142,8 +142,8 @@ private CompletableFuture<FastSyncState> internalDownloadPivotBlockHeader(
                                     ethContext,
                                     metricsSystem,
                                     currentState.getPivotBlockNumber().getAsLong(),
-                                    syncConfig.getFastSyncMinimumPeerCount(),
-                                    syncConfig.getFastSyncPivotDistance())
+                                    syncConfig.getSyncMinimumPeerCount(),
+                                    syncConfig.getSyncPivotDistance())
                                 .downloadPivotBlockHeader()));
   }
 
diff --git a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/FastSyncDownloader.java b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/FastSyncDownloader.java
index 7b64f885c29..565824a7808 100644
--- a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/FastSyncDownloader.java
+++ b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/FastSyncDownloader.java
@@ -1,5 +1,5 @@
 /*
- * Copyright ConsenSys AG.
+ * 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
@@ -80,7 +80,7 @@ public CompletableFuture<FastSyncState> start() {
     if (!running.compareAndSet(false, true)) {
       throw new IllegalStateException("SyncDownloader already running");
     }
-    LOG.info("Starting sync");
+    LOG.info("Starting pivot-based sync");
     return start(initialFastSyncState);
   }
 
@@ -94,7 +94,7 @@ protected CompletableFuture<FastSyncState> start(final FastSyncState fastSyncSta
           onBonsai.clearFlatDatabase();
           onBonsai.clearTrieLog();
         });
-    LOG.debug("Start sync with initial sync state {}", fastSyncState);
+    LOG.debug("Start fast sync with initial sync state {}", fastSyncState);
     return findPivotBlock(fastSyncState, fss -> downloadChainAndWorldState(fastSyncActions, fss));
   }
 
@@ -114,7 +114,9 @@ public CompletableFuture<FastSyncState> findPivotBlock(
   protected CompletableFuture<FastSyncState> handleFailure(final Throwable error) {
     trailingPeerRequirements = Optional.empty();
     Throwable rootCause = ExceptionUtils.rootCause(error);
-    if (rootCause instanceof SyncException) {
+    if (rootCause instanceof NoSyncRequiredException) {
+      return CompletableFuture.completedFuture(new NoSyncRequiredState());
+    } else if (rootCause instanceof SyncException) {
       return CompletableFuture.failedFuture(error);
     } else if (rootCause instanceof StalledDownloadException) {
       LOG.debug("Stalled sync re-pivoting to newer block.");
diff --git a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/NoSyncRequiredException.java b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/NoSyncRequiredException.java
new file mode 100644
index 00000000000..caa45abdc19
--- /dev/null
+++ b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/NoSyncRequiredException.java
@@ -0,0 +1,17 @@
+/*
+ * 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.fastsync;
+
+public class NoSyncRequiredException extends RuntimeException {}
diff --git a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/NoSyncRequiredState.java b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/NoSyncRequiredState.java
new file mode 100644
index 00000000000..9cefe78ed15
--- /dev/null
+++ b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/NoSyncRequiredState.java
@@ -0,0 +1,17 @@
+/*
+ * 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.fastsync;
+
+public class NoSyncRequiredState extends FastSyncState {}
diff --git a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/PivotSelectorFromPeers.java b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/PivotSelectorFromPeers.java
index 6402b58d1fd..16f7e09d6d1 100644
--- a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/PivotSelectorFromPeers.java
+++ b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/PivotSelectorFromPeers.java
@@ -35,8 +35,8 @@ public class PivotSelectorFromPeers implements PivotBlockSelector {
 
   private static final Logger LOG = LoggerFactory.getLogger(PivotSelectorFromPeers.class);
 
-  private final EthContext ethContext;
-  private final SynchronizerConfiguration syncConfig;
+  protected final EthContext ethContext;
+  protected final SynchronizerConfiguration syncConfig;
   private final SyncState syncState;
   private final MetricsSystem metricsSystem;
 
@@ -66,7 +66,7 @@ public CompletableFuture<Void> prepareRetry() {
                     conservativelyEstimatedPivotBlock(), syncConfig.getMaxTrailingPeers()));
     trailingPeerLimiter.enforceTrailingPeerLimit();
 
-    return waitForPeers(syncConfig.getFastSyncMinimumPeerCount());
+    return waitForPeers(syncConfig.getSyncMinimumPeerCount());
   }
 
   @Override
@@ -74,9 +74,9 @@ public long getBestChainHeight() {
     return syncState.bestChainHeight();
   }
 
-  private Optional<FastSyncState> fromBestPeer(final EthPeer peer) {
+  protected Optional<FastSyncState> fromBestPeer(final EthPeer peer) {
     final long pivotBlockNumber =
-        peer.chainState().getEstimatedHeight() - syncConfig.getFastSyncPivotDistance();
+        peer.chainState().getEstimatedHeight() - syncConfig.getSyncPivotDistance();
     if (pivotBlockNumber <= BlockHeader.GENESIS_BLOCK_NUMBER) {
       // Peer's chain isn't long enough, return an empty value, so we can try again.
       LOG.info("Waiting for peers with sufficient chain height");
@@ -86,7 +86,7 @@ private Optional<FastSyncState> fromBestPeer(final EthPeer peer) {
     return Optional.of(new FastSyncState(pivotBlockNumber));
   }
 
-  private Optional<EthPeer> selectBestPeer() {
+  protected Optional<EthPeer> selectBestPeer() {
     return ethContext
         .getEthPeers()
         .bestPeerMatchingCriteria(this::canPeerDeterminePivotBlock)
@@ -96,7 +96,7 @@ private Optional<EthPeer> selectBestPeer() {
 
   private boolean enoughFastSyncPeersArePresent() {
     final long peerCount = countPeersThatCanDeterminePivotBlock();
-    final int minPeerCount = syncConfig.getFastSyncMinimumPeerCount();
+    final int minPeerCount = syncConfig.getSyncMinimumPeerCount();
     if (peerCount < minPeerCount) {
       LOG.info(
           "Waiting for valid peers with chain height information.  {} / {} required peers currently available.",
@@ -126,7 +126,7 @@ private boolean canPeerDeterminePivotBlock(final EthPeer peer) {
 
   private long conservativelyEstimatedPivotBlock() {
     final long estimatedNextPivot =
-        syncState.getLocalChainHeight() + syncConfig.getFastSyncPivotDistance();
+        syncState.getLocalChainHeight() + syncConfig.getSyncPivotDistance();
     return Math.min(syncState.bestChainHeight(), estimatedNextPivot);
   }
 
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 669287cfef2..dbe043b92a0 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
@@ -38,6 +38,8 @@ public class SnapSyncConfiguration {
 
   public static final Boolean DEFAULT_SNAP_SERVER_ENABLED = Boolean.FALSE;
 
+  public static final Boolean DEFAULT_SNAP_SYNC_BFT_ENABLED = Boolean.FALSE;
+
   public static SnapSyncConfiguration getDefault() {
     return ImmutableSnapSyncConfiguration.builder().build();
   }
@@ -81,4 +83,9 @@ public int getLocalFlatStorageCountToHealPerRequest() {
   public Boolean isSnapServerEnabled() {
     return DEFAULT_SNAP_SERVER_ENABLED;
   }
+
+  @Value.Default
+  public Boolean isSnapSyncBftEnabled() {
+    return DEFAULT_SNAP_SYNC_BFT_ENABLED;
+  }
 }
diff --git a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/snapsync/request/AccountRangeDataRequest.java b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/snapsync/request/AccountRangeDataRequest.java
index 213912a1ac3..21a707e9a63 100644
--- a/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/snapsync/request/AccountRangeDataRequest.java
+++ b/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/sync/snapsync/request/AccountRangeDataRequest.java
@@ -58,12 +58,12 @@ public class AccountRangeDataRequest extends SnapDataRequest {
 
   private static final Logger LOG = LoggerFactory.getLogger(AccountRangeDataRequest.class);
 
-  private final Bytes32 startKeyHash;
-  private final Bytes32 endKeyHash;
-  private final Optional<Bytes32> startStorageRange;
-  private final Optional<Bytes32> endStorageRange;
+  protected final Bytes32 startKeyHash;
+  protected final Bytes32 endKeyHash;
+  protected final Optional<Bytes32> startStorageRange;
+  protected final Optional<Bytes32> endStorageRange;
 
-  private final StackTrie stackTrie;
+  protected final StackTrie stackTrie;
   private Optional<Boolean> isProofValid;
 
   protected AccountRangeDataRequest(
@@ -170,6 +170,12 @@ startKeyHash, endKeyHash, getRootHash(), proofs, accounts)) {
       } else {
         stackTrie.addElement(startKeyHash, proofs, accounts);
         isProofValid = Optional.of(true);
+        LOG.atDebug()
+            .setMessage("{} accounts received during sync for account range {} {}")
+            .addArgument(accounts.size())
+            .addArgument(startKeyHash)
+            .addArgument(endKeyHash)
+            .log();
       }
     }
   }
diff --git a/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/FastSyncActionsTest.java b/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/FastSyncActionsTest.java
index e060bab6fbe..d29bb7260e5 100644
--- a/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/FastSyncActionsTest.java
+++ b/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/FastSyncActionsTest.java
@@ -62,7 +62,7 @@
 public class FastSyncActionsTest {
 
   private final SynchronizerConfiguration.Builder syncConfigBuilder =
-      new SynchronizerConfiguration.Builder().syncMode(SyncMode.FAST).fastSyncPivotDistance(1000);
+      new SynchronizerConfiguration.Builder().syncMode(SyncMode.FAST).syncPivotDistance(1000);
 
   private final WorldStateStorageCoordinator worldStateStorageCoordinator =
       mock(WorldStateStorageCoordinator.class);
@@ -113,9 +113,9 @@ public void setUp(final DataStorageFormat storageFormat) {
   public void waitForPeersShouldSucceedIfEnoughPeersAreFound(
       final DataStorageFormat storageFormat) {
     setUp(storageFormat);
-    for (int i = 0; i < syncConfig.getFastSyncMinimumPeerCount(); i++) {
+    for (int i = 0; i < syncConfig.getSyncMinimumPeerCount(); i++) {
       EthProtocolManagerTestUtil.createPeer(
-          ethProtocolManager, syncConfig.getFastSyncPivotDistance() + i + 1);
+          ethProtocolManager, syncConfig.getSyncPivotDistance() + i + 1);
     }
     final CompletableFuture<FastSyncState> result =
         fastSyncActions.selectPivotBlock(FastSyncState.EMPTY_SYNC_STATE);
@@ -153,7 +153,7 @@ public void selectPivotBlockShouldSelectBlockPivotDistanceFromBestPeer(
       final DataStorageFormat storageFormat) {
     setUp(storageFormat);
     final int minPeers = 1;
-    syncConfigBuilder.fastSyncMinimumPeerCount(minPeers);
+    syncConfigBuilder.syncMinimumPeerCount(minPeers);
     syncConfig = syncConfigBuilder.build();
     fastSyncActions =
         createFastSyncActions(
@@ -174,7 +174,7 @@ public void selectPivotBlockShouldConsiderTotalDifficultyWhenSelectingBestPeer(
       final DataStorageFormat storageFormat) {
     setUp(storageFormat);
     final int minPeers = 1;
-    syncConfigBuilder.fastSyncMinimumPeerCount(minPeers);
+    syncConfigBuilder.syncMinimumPeerCount(minPeers);
     syncConfig = syncConfigBuilder.build();
     fastSyncActions =
         createFastSyncActions(
@@ -197,7 +197,7 @@ public void selectPivotBlockShouldWaitAndRetryUntilMinHeightEstimatesAreAvailabl
     setUp(storageFormat);
     EthProtocolManagerTestUtil.disableEthSchedulerAutoRun(ethProtocolManager);
     final int minPeers = 2;
-    syncConfigBuilder.fastSyncMinimumPeerCount(minPeers);
+    syncConfigBuilder.syncMinimumPeerCount(minPeers);
     syncConfig = syncConfigBuilder.build();
     fastSyncActions =
         createFastSyncActions(
@@ -228,13 +228,13 @@ public void selectPivotBlockShouldWaitAndRetryIfSufficientChainHeightEstimatesAr
       final DataStorageFormat storageFormat) {
     setUp(storageFormat);
     final int minPeers = 3;
-    syncConfigBuilder.fastSyncMinimumPeerCount(minPeers);
+    syncConfigBuilder.syncMinimumPeerCount(minPeers);
     syncConfig = syncConfigBuilder.build();
     fastSyncActions =
         createFastSyncActions(
             syncConfig,
             new PivotSelectorFromPeers(ethContext, syncConfig, syncState, metricsSystem));
-    final long minPivotHeight = syncConfig.getFastSyncPivotDistance() + 1L;
+    final long minPivotHeight = syncConfig.getSyncPivotDistance() + 1L;
     EthProtocolManagerTestUtil.disableEthSchedulerAutoRun(ethProtocolManager);
 
     // Create peers without chain height estimates
@@ -267,7 +267,7 @@ public void selectPivotBlockShouldWaitAndRetryIfSufficientChainHeightEstimatesAr
     final long bestPeerHeight = minPivotHeight + 1;
     peers.get(minPeers - 1).getEthPeer().chainState().updateHeightEstimate(bestPeerHeight);
     final FastSyncState expected =
-        new FastSyncState(bestPeerHeight - syncConfig.getFastSyncPivotDistance());
+        new FastSyncState(bestPeerHeight - syncConfig.getSyncPivotDistance());
     EthProtocolManagerTestUtil.runPendingFutures(ethProtocolManager);
     assertThat(result).isCompletedWithValue(expected);
   }
@@ -279,13 +279,13 @@ public void selectPivotBlockShouldWaitAndRetryIfSufficientValidatedPeersUnavaila
     setUp(storageFormat);
     final int minPeers = 3;
     final PeerValidator validator = mock(PeerValidator.class);
-    syncConfigBuilder.fastSyncMinimumPeerCount(minPeers);
+    syncConfigBuilder.syncMinimumPeerCount(minPeers);
     syncConfig = syncConfigBuilder.build();
     fastSyncActions =
         createFastSyncActions(
             syncConfig,
             new PivotSelectorFromPeers(ethContext, syncConfig, syncState, metricsSystem));
-    final long minPivotHeight = syncConfig.getFastSyncPivotDistance() + 1L;
+    final long minPivotHeight = syncConfig.getSyncPivotDistance() + 1L;
     EthProtocolManagerTestUtil.disableEthSchedulerAutoRun(ethProtocolManager);
 
     // Create peers that are not validated
@@ -319,7 +319,7 @@ public void selectPivotBlockShouldWaitAndRetryIfSufficientValidatedPeersUnavaila
     bestPeer.chainState().updateHeightEstimate(bestPeerHeight);
     bestPeer.markValidated(validator);
     final FastSyncState expected =
-        new FastSyncState(bestPeerHeight - syncConfig.getFastSyncPivotDistance());
+        new FastSyncState(bestPeerHeight - syncConfig.getSyncPivotDistance());
     EthProtocolManagerTestUtil.runPendingFutures(ethProtocolManager);
     assertThat(result).isCompletedWithValue(expected);
   }
@@ -351,13 +351,13 @@ private void selectPivotBlockUsesBestPeerMatchingRequiredCriteria(
       final boolean bestMissingHeight, final boolean bestNotValidated) {
     final int minPeers = 3;
     final int peerCount = minPeers + 1;
-    syncConfigBuilder.fastSyncMinimumPeerCount(minPeers);
+    syncConfigBuilder.syncMinimumPeerCount(minPeers);
     syncConfig = syncConfigBuilder.build();
     fastSyncActions =
         createFastSyncActions(
             syncConfig,
             new PivotSelectorFromPeers(ethContext, syncConfig, syncState, metricsSystem));
-    final long minPivotHeight = syncConfig.getFastSyncPivotDistance() + 1L;
+    final long minPivotHeight = syncConfig.getSyncPivotDistance() + 1L;
     EthProtocolManagerTestUtil.disableEthSchedulerAutoRun(ethProtocolManager);
 
     // Create peers without chain height estimates
@@ -392,7 +392,7 @@ private void selectPivotBlockUsesBestPeerMatchingRequiredCriteria(
     final long expectedBestChainHeight =
         peers.get(1).getEthPeer().chainState().getEstimatedHeight();
     final FastSyncState expected =
-        new FastSyncState(expectedBestChainHeight - syncConfig.getFastSyncPivotDistance());
+        new FastSyncState(expectedBestChainHeight - syncConfig.getSyncPivotDistance());
     EthProtocolManagerTestUtil.runPendingFutures(ethProtocolManager);
     assertThat(result).isCompletedWithValue(expected);
   }
@@ -403,13 +403,13 @@ public void selectPivotBlockShouldWaitAndRetryIfBestPeerChainIsShorterThanPivotD
       final DataStorageFormat storageFormat) {
     setUp(storageFormat);
     final int minPeers = 1;
-    syncConfigBuilder.fastSyncMinimumPeerCount(minPeers);
+    syncConfigBuilder.syncMinimumPeerCount(minPeers);
     syncConfig = syncConfigBuilder.build();
     fastSyncActions =
         createFastSyncActions(
             syncConfig,
             new PivotSelectorFromPeers(ethContext, syncConfig, syncState, metricsSystem));
-    final long pivotDistance = syncConfig.getFastSyncPivotDistance();
+    final long pivotDistance = syncConfig.getSyncPivotDistance();
 
     EthProtocolManagerTestUtil.disableEthSchedulerAutoRun(ethProtocolManager);
     EthProtocolManagerTestUtil.createPeer(ethProtocolManager, pivotDistance - 1);
@@ -432,10 +432,10 @@ public void selectPivotBlockShouldWaitAndRetryIfBestPeerChainIsShorterThanPivotD
   public void selectPivotBlockShouldRetryIfBestPeerChainIsEqualToPivotDistance(
       final DataStorageFormat storageFormat) {
     setUp(storageFormat);
-    final long pivotDistance = syncConfig.getFastSyncPivotDistance();
+    final long pivotDistance = syncConfig.getSyncPivotDistance();
     EthProtocolManagerTestUtil.disableEthSchedulerAutoRun(ethProtocolManager);
     // Create peers with chains that are too short
-    for (int i = 0; i < syncConfig.getFastSyncMinimumPeerCount(); i++) {
+    for (int i = 0; i < syncConfig.getSyncMinimumPeerCount(); i++) {
       EthProtocolManagerTestUtil.createPeer(ethProtocolManager, pivotDistance);
     }
 
@@ -467,7 +467,7 @@ public void downloadPivotBlockHeaderShouldUseExistingPivotBlockHeaderIfPresent(
   public void downloadPivotBlockHeaderShouldRetrievePivotBlockHeader(
       final DataStorageFormat storageFormat) {
     setUp(storageFormat);
-    syncConfig = SynchronizerConfiguration.builder().fastSyncMinimumPeerCount(1).build();
+    syncConfig = SynchronizerConfiguration.builder().syncMinimumPeerCount(1).build();
     fastSyncActions =
         createFastSyncActions(
             syncConfig,
@@ -489,7 +489,7 @@ public void downloadPivotBlockHeaderShouldRetrievePivotBlockHeader(
   public void downloadPivotBlockHeaderShouldRetrievePivotBlockHash(
       final DataStorageFormat storageFormat) {
     setUp(storageFormat);
-    syncConfig = SynchronizerConfiguration.builder().fastSyncMinimumPeerCount(1).build();
+    syncConfig = SynchronizerConfiguration.builder().syncMinimumPeerCount(1).build();
     GenesisConfigOptions genesisConfig = mock(GenesisConfigOptions.class);
     when(genesisConfig.getTerminalBlockNumber()).thenReturn(OptionalLong.of(10L));
 
diff --git a/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/worldstate/LoadLocalDataStepTest.java b/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/worldstate/LoadLocalDataStepTest.java
index 6707ed97054..582bdff6335 100644
--- a/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/worldstate/LoadLocalDataStepTest.java
+++ b/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/fastsync/worldstate/LoadLocalDataStepTest.java
@@ -51,7 +51,7 @@ public class LoadLocalDataStepTest {
   private final Task<NodeDataRequest> task = new StubTask(request);
 
   private final Pipe<Task<NodeDataRequest>> completedTasks =
-      new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER);
+      new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER, "test_pipe");
   private final LoadLocalDataStep loadLocalDataStep =
       new LoadLocalDataStep(
           new WorldStateStorageCoordinator(worldStateKeyValueStorage), new NoOpMetricsSystem());
diff --git a/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/snapsync/LoadLocalDataStepTest.java b/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/snapsync/LoadLocalDataStepTest.java
index 9027538ce51..06f92460c27 100644
--- a/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/snapsync/LoadLocalDataStepTest.java
+++ b/ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/sync/snapsync/LoadLocalDataStepTest.java
@@ -55,7 +55,7 @@ public class LoadLocalDataStepTest {
   private final Task<SnapDataRequest> task = new StubTask(request);
 
   private final Pipe<Task<SnapDataRequest>> completedTasks =
-      new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER);
+      new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER, "test_pipe");
 
   private final SnapSyncProcessState snapSyncState = mock(SnapSyncProcessState.class);
   private final SnapWorldDownloadState downloadState = mock(SnapWorldDownloadState.class);
diff --git a/ethereum/trie/src/main/java/org/hyperledger/besu/ethereum/trie/patricia/TrieNodeDecoder.java b/ethereum/trie/src/main/java/org/hyperledger/besu/ethereum/trie/patricia/TrieNodeDecoder.java
index b3476337a77..6179f45fc0a 100644
--- a/ethereum/trie/src/main/java/org/hyperledger/besu/ethereum/trie/patricia/TrieNodeDecoder.java
+++ b/ethereum/trie/src/main/java/org/hyperledger/besu/ethereum/trie/patricia/TrieNodeDecoder.java
@@ -16,6 +16,7 @@
 
 import static com.google.common.base.Preconditions.checkArgument;
 
+import org.hyperledger.besu.ethereum.trie.MerkleTrie;
 import org.hyperledger.besu.ethereum.trie.Node;
 import org.hyperledger.besu.ethereum.trie.NodeLoader;
 import org.hyperledger.besu.ethereum.trie.NullNode;
@@ -59,6 +60,9 @@ public static Node<Bytes> decode(final Bytes location, final Bytes rlp) {
    * @return A list of nodes and node references embedded in the given rlp.
    */
   public static List<Node<Bytes>> decodeNodes(final Bytes location, final Bytes nodeRlp) {
+    if (nodeRlp.equals(MerkleTrie.EMPTY_TRIE_NODE)) {
+      return new ArrayList<>();
+    }
     final Node<Bytes> node = decode(location, nodeRlp);
     final List<Node<Bytes>> nodes = new ArrayList<>();
     nodes.add(node);
diff --git a/services/pipeline/src/main/java/org/hyperledger/besu/services/pipeline/AsyncOperationProcessor.java b/services/pipeline/src/main/java/org/hyperledger/besu/services/pipeline/AsyncOperationProcessor.java
index f64454fa9f1..c8c7e5905db 100644
--- a/services/pipeline/src/main/java/org/hyperledger/besu/services/pipeline/AsyncOperationProcessor.java
+++ b/services/pipeline/src/main/java/org/hyperledger/besu/services/pipeline/AsyncOperationProcessor.java
@@ -83,7 +83,7 @@ private void outputNextCompletedTask(final WritePipe<O> outputPipe) {
       waitForAnyFutureToComplete();
       outputCompletedTasks(outputPipe);
     } catch (final InterruptedException e) {
-      LOG.trace("Interrupted while waiting for processing to complete", e);
+      LOG.trace("Interrupted while waiting for processing to complete", e.getMessage());
     } catch (final ExecutionException e) {
       throw new AsyncOperationException("Async operation failed. " + e.getMessage(), e);
     } catch (final TimeoutException e) {
diff --git a/services/pipeline/src/main/java/org/hyperledger/besu/services/pipeline/Pipe.java b/services/pipeline/src/main/java/org/hyperledger/besu/services/pipeline/Pipe.java
index 3697e0e3ba2..63fb01bad13 100644
--- a/services/pipeline/src/main/java/org/hyperledger/besu/services/pipeline/Pipe.java
+++ b/services/pipeline/src/main/java/org/hyperledger/besu/services/pipeline/Pipe.java
@@ -44,6 +44,7 @@ public class Pipe<T> implements ReadPipe<T>, WritePipe<T> {
   private final Counter abortedItemCounter;
   private final AtomicBoolean closed = new AtomicBoolean();
   private final AtomicBoolean aborted = new AtomicBoolean();
+  private String pipeName = "";
 
   /**
    * Instantiates a new Pipe.
@@ -52,16 +53,28 @@ public class Pipe<T> implements ReadPipe<T>, WritePipe<T> {
    * @param inputCounter the input counter
    * @param outputCounter the output counter
    * @param abortedItemCounter the aborted item counter
+   * @param pipeName the name of the pipe
    */
   public Pipe(
       final int capacity,
       final Counter inputCounter,
       final Counter outputCounter,
-      final Counter abortedItemCounter) {
+      final Counter abortedItemCounter,
+      final String pipeName) {
     queue = new ArrayBlockingQueue<>(capacity);
     this.inputCounter = inputCounter;
     this.outputCounter = outputCounter;
     this.abortedItemCounter = abortedItemCounter;
+    this.pipeName = pipeName;
+  }
+
+  /**
+   * Get the name of this pipe
+   *
+   * @return the name of the pipe
+   */
+  public String getPipeName() {
+    return pipeName;
   }
 
   @Override
@@ -110,7 +123,7 @@ public T get() {
         }
       }
     } catch (final InterruptedException e) {
-      LOG.trace("Interrupted while waiting for next item", e);
+      LOG.trace("Interrupted while waiting for next item from pipe {}", pipeName);
     }
     return null;
   }
@@ -140,7 +153,7 @@ public void put(final T value) {
           return;
         }
       } catch (final InterruptedException e) {
-        LOG.trace("Interrupted while waiting to add to output", e);
+        LOG.trace("Interrupted while waiting to add to output to pipe {}", pipeName);
       }
     }
   }
diff --git a/services/pipeline/src/main/java/org/hyperledger/besu/services/pipeline/Pipeline.java b/services/pipeline/src/main/java/org/hyperledger/besu/services/pipeline/Pipeline.java
index 7f37a4bac91..507e87a8c0c 100644
--- a/services/pipeline/src/main/java/org/hyperledger/besu/services/pipeline/Pipeline.java
+++ b/services/pipeline/src/main/java/org/hyperledger/besu/services/pipeline/Pipeline.java
@@ -89,6 +89,19 @@ public class Pipeline<I> {
     this.stages = stages;
     this.pipes = pipes;
     this.completerStage = completerStage;
+
+    if (LOG.isTraceEnabled()) {
+      StringBuilder sb = new StringBuilder();
+      sb.append("Building pipeline ");
+      sb.append(name);
+      sb.append(". Stages: ");
+      for (Stage nextStage : stages) {
+        sb.append(nextStage.getName());
+        sb.append(" -> ");
+      }
+      sb.append("END");
+      LOG.trace("{}", sb.toString());
+    }
   }
 
   /**
diff --git a/services/pipeline/src/main/java/org/hyperledger/besu/services/pipeline/PipelineBuilder.java b/services/pipeline/src/main/java/org/hyperledger/besu/services/pipeline/PipelineBuilder.java
index 3bc6656e700..aaf68f5e3f1 100644
--- a/services/pipeline/src/main/java/org/hyperledger/besu/services/pipeline/PipelineBuilder.java
+++ b/services/pipeline/src/main/java/org/hyperledger/besu/services/pipeline/PipelineBuilder.java
@@ -421,6 +421,7 @@ private static <O> Pipe<O> createPipe(
         newBufferSize,
         outputCounter.labels(labelName, "added"),
         outputCounter.labels(labelName, "removed"),
-        outputCounter.labels(labelName, "aborted"));
+        outputCounter.labels(labelName, "aborted"),
+        stageName);
   }
 }
diff --git a/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/BatchingReadPipeTest.java b/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/BatchingReadPipeTest.java
index fb90128fbb3..da0908e8148 100644
--- a/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/BatchingReadPipeTest.java
+++ b/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/BatchingReadPipeTest.java
@@ -31,7 +31,8 @@
 
 public class BatchingReadPipeTest {
 
-  private final Pipe<String> source = new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER);
+  private final Pipe<String> source =
+      new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER, "source_pipe");
   private final Counter batchCounter = mock(Counter.class);
   private final BatchingReadPipe<String> batchingPipe =
       new BatchingReadPipe<>(source, 3, batchCounter);
diff --git a/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/CompleterStageTest.java b/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/CompleterStageTest.java
index ef3e29afebe..ea4a81a9d98 100644
--- a/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/CompleterStageTest.java
+++ b/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/CompleterStageTest.java
@@ -24,7 +24,8 @@
 
 public class CompleterStageTest {
 
-  private final Pipe<String> pipe = new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER);
+  private final Pipe<String> pipe =
+      new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER, "test_pipe");
   private final List<String> output = new ArrayList<>();
   private final CompleterStage<String> stage = new CompleterStage<>("name", pipe, output::add);
 
diff --git a/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/FlatMapProcessorTest.java b/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/FlatMapProcessorTest.java
index 1012d3b0123..4e3b8cfa513 100644
--- a/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/FlatMapProcessorTest.java
+++ b/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/FlatMapProcessorTest.java
@@ -28,8 +28,10 @@
 
 public class FlatMapProcessorTest {
 
-  private final Pipe<String> input = new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER);
-  private final Pipe<String> output = new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER);
+  private final Pipe<String> input =
+      new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER, "input_pipe");
+  private final Pipe<String> output =
+      new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER, "output_pipe");
 
   @SuppressWarnings("unchecked")
   private final Function<String, Stream<String>> mapper = mock(Function.class);
diff --git a/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/IteratorSourceStageTest.java b/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/IteratorSourceStageTest.java
index 02052615b75..915a90b1fd3 100644
--- a/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/IteratorSourceStageTest.java
+++ b/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/IteratorSourceStageTest.java
@@ -22,7 +22,8 @@
 
 public class IteratorSourceStageTest {
 
-  private final Pipe<String> output = new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER);
+  private final Pipe<String> output =
+      new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER, "output_pipe");
 
   private final IteratorSourceStage<String> stage =
       new IteratorSourceStage<>("name", Iterators.forArray("a", "b", "c", "d"), output);
diff --git a/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/MapProcessorTest.java b/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/MapProcessorTest.java
index 0d7a913c3e3..7698e8d3279 100644
--- a/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/MapProcessorTest.java
+++ b/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/MapProcessorTest.java
@@ -27,8 +27,10 @@
 
 public class MapProcessorTest {
 
-  private final Pipe<String> input = new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER);
-  private final Pipe<String> output = new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER);
+  private final Pipe<String> input =
+      new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER, "intput_pipe");
+  private final Pipe<String> output =
+      new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER, "output_pipe");
 
   @SuppressWarnings("unchecked")
   private final Function<String, String> processor = mock(Function.class);
diff --git a/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/PipeTest.java b/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/PipeTest.java
index c838bc887a3..c4a7a88b527 100644
--- a/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/PipeTest.java
+++ b/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/PipeTest.java
@@ -30,7 +30,8 @@ public class PipeTest {
   private final Counter inputCounter = mock(Counter.class);
   private final Counter outputCounter = mock(Counter.class);
   private final Counter abortedItemCounter = mock(Counter.class);
-  private final Pipe<String> pipe = new Pipe<>(5, inputCounter, outputCounter, abortedItemCounter);
+  private final Pipe<String> pipe =
+      new Pipe<>(5, inputCounter, outputCounter, abortedItemCounter, "test_pipe");
 
   @Test
   public void shouldNotHaveMoreWhenEmptyAndClosed() {
diff --git a/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/ProcessingStageTest.java b/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/ProcessingStageTest.java
index efbe16da668..a07530f5497 100644
--- a/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/ProcessingStageTest.java
+++ b/services/pipeline/src/test/java/org/hyperledger/besu/services/pipeline/ProcessingStageTest.java
@@ -34,9 +34,9 @@
 public class ProcessingStageTest {
 
   private final Pipe<String> inputPipe =
-      new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER);
+      new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER, "input_pipe");
   private final Pipe<String> outputPipe =
-      new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER);
+      new Pipe<>(10, NO_OP_COUNTER, NO_OP_COUNTER, NO_OP_COUNTER, "output_pipe");
   @Mock private Processor<String, String> singleStep;
   private ProcessingStage<String, String> stage;