diff --git a/Cargo.lock b/Cargo.lock
index d446636..d888dca 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1186,7 +1186,7 @@ dependencies = [
 
 [[package]]
 name = "casper-runtime"
-version = "3.5.23"
+version = "3.5.24"
 dependencies = [
  "casper-runtime-constants",
  "frame-benchmarking",
@@ -3834,7 +3834,7 @@ dependencies = [
 
 [[package]]
 name = "ghost-slow-clap"
-version = "0.3.27"
+version = "0.3.28"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
diff --git a/pallets/slow-clap/Cargo.toml b/pallets/slow-clap/Cargo.toml
index ca3e9bc..d7a3ddf 100644
--- a/pallets/slow-clap/Cargo.toml
+++ b/pallets/slow-clap/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ghost-slow-clap"
-version = "0.3.27"
+version = "0.3.28"
 description = "Applause protocol for the EVM bridge"
 license.workspace = true
 authors.workspace = true
diff --git a/pallets/slow-clap/src/lib.rs b/pallets/slow-clap/src/lib.rs
index 8c26ed8..acd3af9 100644
--- a/pallets/slow-clap/src/lib.rs
+++ b/pallets/slow-clap/src/lib.rs
@@ -687,6 +687,7 @@ impl<T: Config> Pallet<T> {
         let network_id_encoded = network_id.encode();
 
         let block_number_key = Self::create_storage_key(b"block-", &network_id_encoded);
+        let block_distance_key = Self::create_storage_key(b"block-distance-", &network_id_encoded);
         let endpoint_key = Self::create_storage_key(b"endpoint-", &network_id_encoded);
 
         let rpc_endpoint = StorageValueRef::persistent(&endpoint_key)
@@ -695,6 +696,12 @@ impl<T: Config> Pallet<T> {
             .flatten()
             .unwrap_or(network_data.default_endpoint.clone());
 
+        let max_block_distance = StorageValueRef::persistent(&block_distance_key)
+            .get()
+            .ok()
+            .flatten()
+            .unwrap_or(network_data.block_distance);
+
         let mutation_result = StorageValueRef::persistent(&block_number_key).mutate(|result_block_range: Result<Option<(u64, u64)>, StorageRetrievalError>| {
             match result_block_range {
                 Ok(maybe_block_range) => {
@@ -708,7 +715,7 @@ impl<T: Config> Pallet<T> {
 
                     match network_data.network_type {
                         NetworkType::Evm => {
-                            let new_evm_block = Self::apply_evm_response(
+                            let maybe_new_evm_block = Self::apply_evm_response(
                                 &response_bytes,
                                 authority_index,
                                 authority_key,
@@ -717,12 +724,20 @@ impl<T: Config> Pallet<T> {
                             )?;
 
                             let finality_delay = network_data.finality_delay.unwrap_or_default();
-                            let estimated_block = new_evm_block.saturating_sub(finality_delay);
+                            let estimated_block = maybe_new_evm_block
+                                .map(|new_evm_block| new_evm_block.saturating_sub(finality_delay))
+                                .unwrap_or_default();
 
                             Ok(match maybe_block_range {
-                                Some((from_block, to_block)) => match new_evm_block {
-                                    0 => (to_block, to_block),
-                                    _ => (from_block, estimated_block),
+                                Some((from_block, to_block)) => match maybe_new_evm_block {
+                                    Some(_) => match estimated_block.checked_sub(from_block) {
+                                        Some(current_distance) if current_distance < max_block_distance =>
+                                            (from_block, estimated_block),
+                                        _ => (from_block, from_block
+                                                .saturating_add(max_block_distance)
+                                                .min(estimated_block)),
+                                    },
+                                    None => (to_block, to_block),
                                 },
                                 None => (estimated_block, estimated_block),
                             })
@@ -748,7 +763,7 @@ impl<T: Config> Pallet<T> {
         authority_key: T::AuthorityId,
         session_index: SessionIndex,
         network_id: NetworkIdOf<T>
-    ) -> OffchainResult<T, u64> {
+    ) -> OffchainResult<T, Option<u64>> {
         match Self::parse_evm_response(&response_bytes)? {
             EvmResponseType::BlockNumber(new_evm_block) => {
                 log::info!(
@@ -757,7 +772,7 @@ impl<T: Config> Pallet<T> {
                     new_evm_block,
                     network_id,
                 );
-                Ok(new_evm_block)
+                Ok(Some(new_evm_block))
             },
             EvmResponseType::TransactionLogs(evm_logs) => {
                 let claps: Vec<_> = evm_logs
@@ -799,7 +814,7 @@ impl<T: Config> Pallet<T> {
                         .map_err(|_| OffchainErr::SubmitTransaction)?;
                 }
 
-                Ok(0u64)
+                Ok(None)
             }
         }
     }
diff --git a/pallets/slow-clap/src/tests.rs b/pallets/slow-clap/src/tests.rs
index cad712f..6ae6194 100644
--- a/pallets/slow-clap/src/tests.rs
+++ b/pallets/slow-clap/src/tests.rs
@@ -24,7 +24,7 @@ fn prepare_evm_network(
         chain_name: "Ethereum".into(),
         default_endpoint: get_rpc_endpoint(),
         finality_delay: Some(69),
-        release_delay: Some(69),
+        block_distance: 69,
         network_type: ghost_networks::NetworkType::Evm,
         gatekeeper: get_gatekeeper(),
         topic_name: get_topic_name(),
@@ -197,9 +197,9 @@ fn should_make_http_call_and_parse_block_number() {
 
         let request_body = SlowClap::prepare_request_body_for_latest_block(&network_data);
         let raw_response = SlowClap::fetch_from_remote(&rpc_endpoint, &request_body)?;
-        let evm_block_number = SlowClap::apply_evm_response(&raw_response, 69, Default::default(), 420, 1)?;
+        let maybe_evm_block_number = SlowClap::apply_evm_response(&raw_response, 69, Default::default(), 420, 1)?;
 
-        assert_eq!(evm_block_number, 20335745);
+        assert_eq!(maybe_evm_block_number, Some(20335745));
         Ok(())
     });
 }
@@ -234,7 +234,7 @@ fn should_make_http_call_and_parse_logs() {
             EvmResponseType::TransactionLogs(evm_logs) => assert_eq!(evm_logs.len(), 2),
         }
 
-        let evm_block_number = SlowClap::apply_evm_response(
+        let maybe_evm_block_number = SlowClap::apply_evm_response(
             &raw_response,
             1,
             UintAuthorityId::from(2),
@@ -242,7 +242,7 @@ fn should_make_http_call_and_parse_logs() {
             network_id,
         )?;
 
-        assert_eq!(evm_block_number, 0);
+        assert_eq!(maybe_evm_block_number, None);
         Ok(())
     });
 }