diff --git a/src/kernel_evm/kernel/src/lib.rs b/src/kernel_evm/kernel/src/lib.rs
index 0655222d4ee162e40b06b7de3af26339a995f47d..0726fa257be9c5d3742e02b40b77be3506865787 100644
--- a/src/kernel_evm/kernel/src/lib.rs
+++ b/src/kernel_evm/kernel/src/lib.rs
@@ -40,20 +40,24 @@ pub fn stage_one<Host: Runtime>(
 pub fn stage_two<Host: Runtime>(host: &mut Host, queue: Queue) -> Result<(), Error> {
     block::produce(host, queue)?;
 
-    if let Ok(L2Block {
-        number,
-        hash,
-        transactions,
-        ..
-    }) = storage::read_current_block(host)
-    {
-        debug_msg!(
-            host,
-            "Block {} at number {} contains {} transaction(s).\n",
-            String::from_utf8(hash.to_vec()).expect("INVALID HASH"),
+    match storage::read_current_block(host) {
+        Ok(L2Block {
             number,
-            transactions.len()
-        )
+            hash,
+            transactions,
+            ..
+        }) => {
+            debug_msg!(
+                host,
+                "Block {} at number {} contains {} transaction(s).\n",
+                String::from_utf8(hash.to_vec()).expect("INVALID HASH"),
+                number,
+                transactions.len()
+            )
+        }
+        Err(e) => {
+            debug_msg!(host, "Block reading failed: {:?}\n", e)
+        }
     }
 
     Ok(())
diff --git a/src/kernel_evm/kernel/src/storage.rs b/src/kernel_evm/kernel/src/storage.rs
index 2a699169f596c4b816a4a934121192b84b4eed00..f9c4b88c4ef4f39072da0c85297a66c045358366 100644
--- a/src/kernel_evm/kernel/src/storage.rs
+++ b/src/kernel_evm/kernel/src/storage.rs
@@ -52,6 +52,24 @@ const TRANSACTION_RECEIPT_STATUS_SIZE: usize = 1;
 // TRANSACTION_HASH_SIZE * 128 = 4096.
 const MAX_TRANSACTION_HASHES: usize = TRANSACTION_HASH_SIZE * 128;
 
+// This function should be used when it makes sense that the value
+// stored under [path] can be empty.
+fn store_read_empty_safe<Host: Runtime>(
+    host: &mut Host,
+    path: &OwnedPath,
+    offset: usize,
+    max_bytes: usize,
+) -> Result<Vec<u8>, Error> {
+    let stored_value_size = host.store_value_size(path)?;
+
+    if stored_value_size == 0 {
+        Ok(vec![])
+    } else {
+        host.store_read(path, offset, max_bytes)
+            .map_err(Error::from)
+    }
+}
+
 fn store_read_slice<Host: Runtime, T: Path>(
     host: &mut Host,
     path: &T,
@@ -230,7 +248,8 @@ fn read_nth_block_transactions<Host: Runtime>(
 ) -> Result<Vec<TransactionHash>, Error> {
     let path = concat(block_path, &EVM_BLOCKS_TRANSACTIONS)?;
 
-    let transactions_bytes = host.store_read(&path, 0, MAX_TRANSACTION_HASHES)?;
+    let transactions_bytes =
+        store_read_empty_safe(host, &path, 0, MAX_TRANSACTION_HASHES)?;
 
     Ok(transactions_bytes
         .chunks(TRANSACTION_HASH_SIZE)