diff --git a/cmd/geth/main.go b/cmd/geth/main.go
index 158b087960..e9deec61f2 100644
--- a/cmd/geth/main.go
+++ b/cmd/geth/main.go
@@ -50,7 +50,7 @@ import _ "net/http/pprof"
 
 const (
 	ClientIdentifier = "Geth"
-	Version          = "0.9.21"
+	Version          = "0.9.21.1"
 )
 
 var (
diff --git a/core/block_processor.go b/core/block_processor.go
index 9a213686f8..cae618b390 100644
--- a/core/block_processor.go
+++ b/core/block_processor.go
@@ -343,23 +343,23 @@ func (sm *BlockProcessor) VerifyUncles(statedb *state.StateDB, block, parent *ty
 
 	uncles.Add(block.Hash())
 	for i, uncle := range block.Uncles() {
-		if uncles.Has(uncle.Hash()) {
+		hash := uncle.Hash()
+		if uncles.Has(hash) {
 			// Error not unique
-			return UncleError("uncle[%d] not unique", i)
+			return UncleError("uncle[%d](%x) not unique", i, hash[:4])
 		}
+		uncles.Add(hash)
 
-		uncles.Add(uncle.Hash())
-
-		if ancestors.Has(uncle.Hash()) {
-			return UncleError("uncle[%d] is ancestor", i)
+		if ancestors.Has(hash) {
+			return UncleError("uncle[%d](%x) is ancestor", i, hash[:4])
 		}
 
 		if !ancestors.Has(uncle.ParentHash) {
-			return UncleError("uncle[%d]'s parent unknown (%x)", i, uncle.ParentHash[0:4])
+			return UncleError("uncle[%d](%x)'s parent unknown (%x)", i, hash[:4], uncle.ParentHash[0:4])
 		}
 
 		if err := sm.ValidateHeader(uncle, ancestorHeaders[uncle.ParentHash]); err != nil {
-			return ValidationError(fmt.Sprintf("uncle[%d](%x) header invalid: %v", i, uncle.Hash().Bytes()[:4], err))
+			return ValidationError(fmt.Sprintf("uncle[%d](%x) header invalid: %v", i, hash[:4], err))
 		}
 	}
 
diff --git a/eth/downloader/downloader.go b/eth/downloader/downloader.go
index 1bc81406cb..d817b223cc 100644
--- a/eth/downloader/downloader.go
+++ b/eth/downloader/downloader.go
@@ -145,8 +145,6 @@ func (d *Downloader) Synchronise(id string, hash common.Hash) error {
 		glog.V(logger.Info).Infoln("Block synchronisation started")
 	}
 
-	d.mux.Post(StartEvent{})
-
 	// Create cancel channel for aborting mid-flight
 	d.cancelLock.Lock()
 	d.cancelCh = make(chan struct{})
@@ -166,6 +164,7 @@ func (d *Downloader) Synchronise(id string, hash common.Hash) error {
 	if p == nil {
 		return errUnknownPeer
 	}
+
 	return d.syncWithPeer(p, hash)
 }
 
@@ -181,6 +180,7 @@ func (d *Downloader) Has(hash common.Hash) bool {
 // syncWithPeer starts a block synchronization based on the hash chain from the
 // specified peer and head hash.
 func (d *Downloader) syncWithPeer(p *peer, hash common.Hash) (err error) {
+	d.mux.Post(StartEvent{})
 	defer func() {
 		// reset on error
 		if err != nil {
diff --git a/miner/agent.go b/miner/agent.go
index 939f63fef0..da2a2008df 100644
--- a/miner/agent.go
+++ b/miner/agent.go
@@ -11,8 +11,9 @@ import (
 )
 
 type CpuAgent struct {
-	chMu          sync.Mutex
-	c             chan *types.Block
+	mu sync.Mutex
+
+	workCh        chan *types.Block
 	quit          chan struct{}
 	quitCurrentOp chan struct{}
 	returnCh      chan<- *types.Block
@@ -30,19 +31,27 @@ func NewCpuAgent(index int, pow pow.PoW) *CpuAgent {
 	return miner
 }
 
-func (self *CpuAgent) Work() chan<- *types.Block          { return self.c }
+func (self *CpuAgent) Work() chan<- *types.Block          { return self.workCh }
 func (self *CpuAgent) Pow() pow.PoW                       { return self.pow }
 func (self *CpuAgent) SetReturnCh(ch chan<- *types.Block) { self.returnCh = ch }
 
 func (self *CpuAgent) Stop() {
+	self.mu.Lock()
+	defer self.mu.Unlock()
+
 	close(self.quit)
 	close(self.quitCurrentOp)
 }
 
 func (self *CpuAgent) Start() {
+	self.mu.Lock()
+	defer self.mu.Unlock()
+
 	self.quit = make(chan struct{})
-	self.quitCurrentOp = make(chan struct{}, 1)
-	self.c = make(chan *types.Block, 1)
+	// creating current op ch makes sure we're not closing a nil ch
+	// later on
+	self.quitCurrentOp = make(chan struct{})
+	self.workCh = make(chan *types.Block, 1)
 
 	go self.update()
 }
@@ -51,10 +60,10 @@ func (self *CpuAgent) update() {
 out:
 	for {
 		select {
-		case block := <-self.c:
-			self.chMu.Lock()
-			self.quitCurrentOp <- struct{}{}
-			self.chMu.Unlock()
+		case block := <-self.workCh:
+			self.mu.Lock()
+			close(self.quitCurrentOp)
+			self.mu.Unlock()
 
 			go self.mine(block)
 		case <-self.quit:
@@ -62,14 +71,13 @@ out:
 		}
 	}
 
-	//close(self.quitCurrentOp)
 done:
-	// Empty channel
+	// Empty work channel
 	for {
 		select {
-		case <-self.c:
+		case <-self.workCh:
 		default:
-			close(self.c)
+			close(self.workCh)
 
 			break done
 		}
@@ -80,9 +88,9 @@ func (self *CpuAgent) mine(block *types.Block) {
 	glog.V(logger.Debug).Infof("(re)started agent[%d]. mining...\n", self.index)
 
 	// Reset the channel
-	self.chMu.Lock()
-	self.quitCurrentOp = make(chan struct{}, 1)
-	self.chMu.Unlock()
+	self.mu.Lock()
+	self.quitCurrentOp = make(chan struct{})
+	self.mu.Unlock()
 
 	// Mine
 	nonce, mixDigest := self.pow.Search(block, self.quitCurrentOp)