diff --git a/ethcore/src/client/client.rs b/ethcore/src/client/client.rs
index 035b24ad3..a2a0d42af 100644
--- a/ethcore/src/client/client.rs
+++ b/ethcore/src/client/client.rs
@@ -1752,10 +1752,14 @@ impl ImportBlock for Client {
                 Ok(hash)
             }
             // we only care about block errors (not import errors)
-            Err((block, EthcoreError(EthcoreErrorKind::Block(err), _))) => {
+            Err((Some(block), EthcoreError(EthcoreErrorKind::Block(err), _))) => {
                 self.importer
                     .bad_blocks
-                    .report(block.bytes, format!("{:?}", err));
+                    .report(block.bytes, err.to_string());
+                bail!(EthcoreErrorKind::Block(err))
+            }
+            Err((None, EthcoreError(EthcoreErrorKind::Block(err), _))) => {
+                error!(target: "client", "BlockError {} detected but it was missing raw_bytes of the block", err);
                 bail!(EthcoreErrorKind::Block(err))
             }
             Err((_, e)) => Err(e),
diff --git a/ethcore/src/verification/queue/mod.rs b/ethcore/src/verification/queue/mod.rs
index e9d957140..35b50b112 100644
--- a/ethcore/src/verification/queue/mod.rs
+++ b/ethcore/src/verification/queue/mod.rs
@@ -507,36 +507,52 @@ impl<K: Kind> VerificationQueue<K> {
     }
 
     /// Add a block to the queue.
-    pub fn import(&self, input: K::Input) -> Result<H256, (K::Input, Error)> {
+    pub fn import(&self, input: K::Input) -> Result<H256, (Option<K::Input>, Error)> {
         let hash = input.hash();
         let raw_hash = input.raw_hash();
         {
             if self.processing.read().contains_key(&hash) {
                 bail!((
-                    input,
+                    Some(input),
                     ErrorKind::Import(ImportErrorKind::AlreadyQueued).into()
                 ));
             }
 
             let mut bad = self.verification.bad.lock();
             if bad.contains(&hash) || bad.contains(&raw_hash) {
-                bail!((input, ErrorKind::Import(ImportErrorKind::KnownBad).into()));
+                bail!((
+                    Some(input),
+                    ErrorKind::Import(ImportErrorKind::KnownBad).into()
+                ));
             }
 
             if bad.contains(&input.parent_hash()) {
                 bad.insert(hash);
-                bail!((input, ErrorKind::Import(ImportErrorKind::KnownBad).into()));
+                bail!((
+                    Some(input),
+                    ErrorKind::Import(ImportErrorKind::KnownBad).into()
+                ));
             }
         }
 
         match K::create(input, &*self.engine, self.verification.check_seal) {
             Ok(item) => {
+                if self
+                    .processing
+                    .write()
+                    .insert(hash, item.difficulty())
+                    .is_some()
+                {
+                    bail!((
+                        None,
+                        ErrorKind::Import(ImportErrorKind::AlreadyQueued).into()
+                    ));
+                }
                 self.verification
                     .sizes
                     .unverified
                     .fetch_add(item.heap_size_of_children(), AtomicOrdering::SeqCst);
 
-                self.processing.write().insert(hash, item.difficulty());
                 {
                     let mut td = self.total_difficulty.write();
                     *td = *td + item.difficulty();
@@ -563,7 +579,7 @@ impl<K: Kind> VerificationQueue<K> {
                         self.verification.bad.lock().insert(hash);
                     }
                 }
-                Err((input, err))
+                Err((Some(input), err))
             }
         }
     }