diff --git a/client/consensus/common/src/longest_chain.rs b/client/consensus/common/src/longest_chain.rs
index b1f7f94f9eb28..7ec91a5ad87e9 100644
--- a/client/consensus/common/src/longest_chain.rs
+++ b/client/consensus/common/src/longest_chain.rs
@@ -91,11 +91,12 @@ where
 		&self,
 		target_hash: Block::Hash,
 		maybe_max_number: Option<NumberFor<Block>>,
-	) -> Result<Option<Block::Hash>, ConsensusError> {
+	) -> Result<Block::Hash, ConsensusError> {
 		let import_lock = self.backend.get_import_lock();
 		self.backend
 			.blockchain()
 			.best_containing(target_hash, maybe_max_number, import_lock)
+			.map(|maybe_hash| maybe_hash.unwrap_or(target_hash))
 			.map_err(|e| ConsensusError::ChainLookup(e.to_string()).into())
 	}
 }
diff --git a/client/finality-grandpa/src/import.rs b/client/finality-grandpa/src/import.rs
index a86421b4a0ef0..405d65bee91e8 100644
--- a/client/finality-grandpa/src/import.rs
+++ b/client/finality-grandpa/src/import.rs
@@ -117,10 +117,10 @@ where
 						)
 						.await
 				} else {
-					Ok(Some(pending_change.canon_hash))
+					Ok(pending_change.canon_hash)
 				};
 
-				if let Ok(Some(hash)) = effective_block_hash {
+				if let Ok(hash) = effective_block_hash {
 					if let Ok(Some(header)) = self.inner.header(BlockId::Hash(hash)) {
 						if *header.number() == pending_change.effective_number() {
 							out.push((header.hash(), *header.number()));
diff --git a/client/service/test/src/client/mod.rs b/client/service/test/src/client/mod.rs
index 01d46c9678bc6..be6a5e07ff0ff 100644
--- a/client/service/test/src/client/mod.rs
+++ b/client/service/test/src/client/mod.rs
@@ -475,23 +475,6 @@ fn best_containing_with_genesis_block() {
 	assert_eq!(
 		genesis_hash.clone(),
 		block_on(longest_chain_select.finality_target(genesis_hash.clone(), None))
-			.unwrap()
-			.unwrap(),
-	);
-}
-
-#[test]
-fn best_containing_with_hash_not_found() {
-	// block tree:
-	// G
-
-	let (client, longest_chain_select) = TestClientBuilder::new().build_with_longest_chain();
-
-	let uninserted_block = client.new_block(Default::default()).unwrap().build().unwrap().block;
-
-	assert_eq!(
-		None,
-		block_on(longest_chain_select.finality_target(uninserted_block.hash().clone(), None))
 			.unwrap(),
 	);
 }
@@ -670,19 +653,16 @@ fn best_containing_on_longest_chain_with_single_chain_3_blocks() {
 		a2.hash(),
 		block_on(longest_chain_select.finality_target(genesis_hash, None))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a2.hash(),
 		block_on(longest_chain_select.finality_target(a1.hash(), None))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a2.hash(),
 		block_on(longest_chain_select.finality_target(a2.hash(), None))
 			.unwrap()
-			.unwrap()
 	);
 }
 
@@ -817,67 +797,56 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 		a5.hash(),
 		block_on(longest_chain_select.finality_target(genesis_hash, None))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a5.hash(),
 		block_on(longest_chain_select.finality_target(a1.hash(), None))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a5.hash(),
 		block_on(longest_chain_select.finality_target(a2.hash(), None))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a5.hash(),
 		block_on(longest_chain_select.finality_target(a3.hash(), None))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a5.hash(),
 		block_on(longest_chain_select.finality_target(a4.hash(), None))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a5.hash(),
 		block_on(longest_chain_select.finality_target(a5.hash(), None))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		b4.hash(),
 		block_on(longest_chain_select.finality_target(b2.hash(), None))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		b4.hash(),
 		block_on(longest_chain_select.finality_target(b3.hash(), None))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		b4.hash(),
 		block_on(longest_chain_select.finality_target(b4.hash(), None))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		c3.hash(),
 		block_on(longest_chain_select.finality_target(c3.hash(), None))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		d2.hash(),
 		block_on(longest_chain_select.finality_target(d2.hash(), None))
 			.unwrap()
-			.unwrap()
 	);
 
 	// search only blocks with number <= 5. equivalent to without restriction for this scenario
@@ -885,67 +854,56 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 		a5.hash(),
 		block_on(longest_chain_select.finality_target(genesis_hash, Some(5)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a5.hash(),
 		block_on(longest_chain_select.finality_target(a1.hash(), Some(5)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a5.hash(),
 		block_on(longest_chain_select.finality_target(a2.hash(), Some(5)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a5.hash(),
 		block_on(longest_chain_select.finality_target(a3.hash(), Some(5)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a5.hash(),
 		block_on(longest_chain_select.finality_target(a4.hash(), Some(5)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a5.hash(),
 		block_on(longest_chain_select.finality_target(a5.hash(), Some(5)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		b4.hash(),
 		block_on(longest_chain_select.finality_target(b2.hash(), Some(5)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		b4.hash(),
 		block_on(longest_chain_select.finality_target(b3.hash(), Some(5)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		b4.hash(),
 		block_on(longest_chain_select.finality_target(b4.hash(), Some(5)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		c3.hash(),
 		block_on(longest_chain_select.finality_target(c3.hash(), Some(5)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		d2.hash(),
 		block_on(longest_chain_select.finality_target(d2.hash(), Some(5)))
 			.unwrap()
-			.unwrap()
 	);
 
 	// search only blocks with number <= 4
@@ -953,62 +911,59 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 		a4.hash(),
 		block_on(longest_chain_select.finality_target(genesis_hash, Some(4)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a4.hash(),
 		block_on(longest_chain_select.finality_target(a1.hash(), Some(4)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a4.hash(),
 		block_on(longest_chain_select.finality_target(a2.hash(), Some(4)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a4.hash(),
 		block_on(longest_chain_select.finality_target(a3.hash(), Some(4)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a4.hash(),
 		block_on(longest_chain_select.finality_target(a4.hash(), Some(4)))
 			.unwrap()
-			.unwrap()
 	);
+<<<<<<< HEAD
+	assert_eq!(
+		a5.hash(),
+		block_on(longest_chain_select.finality_target(a5.hash(), Some(4))).unwrap()
+	);
+=======
 	assert_eq!(None, block_on(longest_chain_select.finality_target(a5.hash(), Some(4))).unwrap());
+>>>>>>> upstream/master
 	assert_eq!(
 		b4.hash(),
 		block_on(longest_chain_select.finality_target(b2.hash(), Some(4)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		b4.hash(),
 		block_on(longest_chain_select.finality_target(b3.hash(), Some(4)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		b4.hash(),
 		block_on(longest_chain_select.finality_target(b4.hash(), Some(4)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		c3.hash(),
 		block_on(longest_chain_select.finality_target(c3.hash(), Some(4)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		d2.hash(),
 		block_on(longest_chain_select.finality_target(d2.hash(), Some(4)))
 			.unwrap()
-			.unwrap()
 	);
 
 	// search only blocks with number <= 3
@@ -1016,52 +971,62 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 		a3.hash(),
 		block_on(longest_chain_select.finality_target(genesis_hash, Some(3)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a3.hash(),
 		block_on(longest_chain_select.finality_target(a1.hash(), Some(3)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a3.hash(),
 		block_on(longest_chain_select.finality_target(a2.hash(), Some(3)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a3.hash(),
 		block_on(longest_chain_select.finality_target(a3.hash(), Some(3)))
 			.unwrap()
-			.unwrap()
 	);
+<<<<<<< HEAD
+	assert_eq!(
+		a4.hash(),
+		block_on(longest_chain_select.finality_target(a4.hash(), Some(3))).unwrap()
+	);
+	assert_eq!(
+		a5.hash(),
+		block_on(longest_chain_select.finality_target(a5.hash(), Some(3))).unwrap()
+	);
+=======
 	assert_eq!(None, block_on(longest_chain_select.finality_target(a4.hash(), Some(3))).unwrap());
 	assert_eq!(None, block_on(longest_chain_select.finality_target(a5.hash(), Some(3))).unwrap());
+>>>>>>> upstream/master
 	assert_eq!(
 		b3.hash(),
 		block_on(longest_chain_select.finality_target(b2.hash(), Some(3)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		b3.hash(),
 		block_on(longest_chain_select.finality_target(b3.hash(), Some(3)))
 			.unwrap()
-			.unwrap()
 	);
+<<<<<<< HEAD
+	assert_eq!(
+		b4.hash(),
+		block_on(longest_chain_select.finality_target(b4.hash(), Some(3))).unwrap()
+	);
+=======
 	assert_eq!(None, block_on(longest_chain_select.finality_target(b4.hash(), Some(3))).unwrap());
+>>>>>>> upstream/master
 	assert_eq!(
 		c3.hash(),
 		block_on(longest_chain_select.finality_target(c3.hash(), Some(3)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		d2.hash(),
 		block_on(longest_chain_select.finality_target(d2.hash(), Some(3)))
 			.unwrap()
-			.unwrap()
 	);
 
 	// search only blocks with number <= 2
@@ -1069,37 +1034,62 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 		a2.hash(),
 		block_on(longest_chain_select.finality_target(genesis_hash, Some(2)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a2.hash(),
 		block_on(longest_chain_select.finality_target(a1.hash(), Some(2)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a2.hash(),
 		block_on(longest_chain_select.finality_target(a2.hash(), Some(2)))
 			.unwrap()
-			.unwrap()
 	);
+<<<<<<< HEAD
+	assert_eq!(
+		a3.hash(),
+		block_on(longest_chain_select.finality_target(a3.hash(), Some(2))).unwrap()
+	);
+	assert_eq!(
+		a4.hash(),
+		block_on(longest_chain_select.finality_target(a4.hash(), Some(2))).unwrap()
+	);
+	assert_eq!(
+		a5.hash(),
+		block_on(longest_chain_select.finality_target(a5.hash(), Some(2))).unwrap()
+	);
+=======
 	assert_eq!(None, block_on(longest_chain_select.finality_target(a3.hash(), Some(2))).unwrap());
 	assert_eq!(None, block_on(longest_chain_select.finality_target(a4.hash(), Some(2))).unwrap());
 	assert_eq!(None, block_on(longest_chain_select.finality_target(a5.hash(), Some(2))).unwrap());
+>>>>>>> upstream/master
 	assert_eq!(
 		b2.hash(),
 		block_on(longest_chain_select.finality_target(b2.hash(), Some(2)))
 			.unwrap()
-			.unwrap()
 	);
+<<<<<<< HEAD
+	assert_eq!(
+		b3.hash(),
+		block_on(longest_chain_select.finality_target(b3.hash(), Some(2))).unwrap()
+	);
+	assert_eq!(
+		b4.hash(),
+		block_on(longest_chain_select.finality_target(b4.hash(), Some(2))).unwrap()
+	);
+	assert_eq!(
+		c3.hash(),
+		block_on(longest_chain_select.finality_target(c3.hash(), Some(2))).unwrap()
+	);
+=======
 	assert_eq!(None, block_on(longest_chain_select.finality_target(b3.hash(), Some(2))).unwrap());
 	assert_eq!(None, block_on(longest_chain_select.finality_target(b4.hash(), Some(2))).unwrap());
 	assert_eq!(None, block_on(longest_chain_select.finality_target(c3.hash(), Some(2))).unwrap());
+>>>>>>> upstream/master
 	assert_eq!(
 		d2.hash(),
 		block_on(longest_chain_select.finality_target(d2.hash(), Some(2)))
 			.unwrap()
-			.unwrap()
 	);
 
 	// search only blocks with number <= 1
@@ -1107,14 +1097,51 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 		a1.hash(),
 		block_on(longest_chain_select.finality_target(genesis_hash, Some(1)))
 			.unwrap()
-			.unwrap()
 	);
 	assert_eq!(
 		a1.hash(),
 		block_on(longest_chain_select.finality_target(a1.hash(), Some(1)))
 			.unwrap()
-			.unwrap()
 	);
+<<<<<<< HEAD
+	assert_eq!(
+		a2.hash(),
+		block_on(longest_chain_select.finality_target(a2.hash(), Some(1))).unwrap()
+	);
+	assert_eq!(
+		a3.hash(),
+		block_on(longest_chain_select.finality_target(a3.hash(), Some(1))).unwrap()
+	);
+	assert_eq!(
+		a4.hash(),
+		block_on(longest_chain_select.finality_target(a4.hash(), Some(1))).unwrap()
+	);
+	assert_eq!(
+		a5.hash(),
+		block_on(longest_chain_select.finality_target(a5.hash(), Some(1))).unwrap()
+	);
+
+	assert_eq!(
+		b2.hash(),
+		block_on(longest_chain_select.finality_target(b2.hash(), Some(1))).unwrap()
+	);
+	assert_eq!(
+		b3.hash(),
+		block_on(longest_chain_select.finality_target(b3.hash(), Some(1))).unwrap()
+	);
+	assert_eq!(
+		b4.hash(),
+		block_on(longest_chain_select.finality_target(b4.hash(), Some(1))).unwrap()
+	);
+	assert_eq!(
+		c3.hash(),
+		block_on(longest_chain_select.finality_target(c3.hash(), Some(1))).unwrap()
+	);
+	assert_eq!(
+		d2.hash(),
+		block_on(longest_chain_select.finality_target(d2.hash(), Some(1))).unwrap()
+	);
+=======
 	assert_eq!(None, block_on(longest_chain_select.finality_target(a2.hash(), Some(1))).unwrap());
 	assert_eq!(None, block_on(longest_chain_select.finality_target(a3.hash(), Some(1))).unwrap());
 	assert_eq!(None, block_on(longest_chain_select.finality_target(a4.hash(), Some(1))).unwrap());
@@ -1125,14 +1152,48 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 	assert_eq!(None, block_on(longest_chain_select.finality_target(b4.hash(), Some(1))).unwrap());
 	assert_eq!(None, block_on(longest_chain_select.finality_target(c3.hash(), Some(1))).unwrap());
 	assert_eq!(None, block_on(longest_chain_select.finality_target(d2.hash(), Some(1))).unwrap());
+>>>>>>> upstream/master
 
 	// search only blocks with number <= 0
 	assert_eq!(
 		genesis_hash,
 		block_on(longest_chain_select.finality_target(genesis_hash, Some(0)))
 			.unwrap()
-			.unwrap()
 	);
+<<<<<<< HEAD
+	assert_eq!(
+		a1.hash(),
+		block_on(longest_chain_select.finality_target(a1.hash(), Some(0))).unwrap()
+	);
+	assert_eq!(
+		a2.hash(),
+		block_on(longest_chain_select.finality_target(a2.hash(), Some(0))).unwrap()
+	);
+	assert_eq!(
+		a3.hash(),
+		block_on(longest_chain_select.finality_target(a3.hash(), Some(0))).unwrap()
+	);
+	assert_eq!(
+		a4.hash(),
+		block_on(longest_chain_select.finality_target(a4.hash(), Some(0))).unwrap()
+	);
+	assert_eq!(
+		a5.hash(),
+		block_on(longest_chain_select.finality_target(a5.hash(), Some(0))).unwrap()
+	);
+	assert_eq!(
+		b2.hash(),
+		block_on(longest_chain_select.finality_target(b2.hash(), Some(0))).unwrap()
+	);
+	assert_eq!(
+		b3.hash(),
+		block_on(longest_chain_select.finality_target(b3.hash(), Some(0))).unwrap()
+	);
+	assert_eq!(
+		b4.hash(),
+		block_on(longest_chain_select.finality_target(b4.hash(), Some(0))).unwrap()
+	);
+=======
 	assert_eq!(None, block_on(longest_chain_select.finality_target(a1.hash(), Some(0))).unwrap());
 	assert_eq!(None, block_on(longest_chain_select.finality_target(a2.hash(), Some(0))).unwrap());
 	assert_eq!(None, block_on(longest_chain_select.finality_target(a3.hash(), Some(0))).unwrap());
@@ -1141,12 +1202,13 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
 	assert_eq!(None, block_on(longest_chain_select.finality_target(b2.hash(), Some(0))).unwrap());
 	assert_eq!(None, block_on(longest_chain_select.finality_target(b3.hash(), Some(0))).unwrap());
 	assert_eq!(None, block_on(longest_chain_select.finality_target(b4.hash(), Some(0))).unwrap());
+>>>>>>> upstream/master
 	assert_eq!(
-		None,
+		c3.hash(),
 		block_on(longest_chain_select.finality_target(c3.hash().clone(), Some(0))).unwrap(),
 	);
 	assert_eq!(
-		None,
+		d2.hash(),
 		block_on(longest_chain_select.finality_target(d2.hash().clone(), Some(0))).unwrap(),
 	);
 }
@@ -1172,7 +1234,6 @@ fn best_containing_on_longest_chain_with_max_depth_higher_than_best() {
 		a2.hash(),
 		block_on(longest_chain_select.finality_target(genesis_hash, Some(10)))
 			.unwrap()
-			.unwrap(),
 	);
 }
 
diff --git a/primitives/consensus/common/src/select_chain.rs b/primitives/consensus/common/src/select_chain.rs
index 5408fc86b7bd4..fd8b06ecf8abb 100644
--- a/primitives/consensus/common/src/select_chain.rs
+++ b/primitives/consensus/common/src/select_chain.rs
@@ -50,7 +50,7 @@ pub trait SelectChain<Block: BlockT>: Sync + Send + Clone {
 		&self,
 		target_hash: <Block as BlockT>::Hash,
 		_maybe_max_number: Option<NumberFor<Block>>,
-	) -> Result<Option<<Block as BlockT>::Hash>, Error> {
-		Ok(Some(target_hash))
+	) -> Result<<Block as BlockT>::Hash, Error> {
+		Ok(target_hash)
 	}
 }