diff --git a/packages/autopeering/discover/manager_test.go b/packages/autopeering/discover/manager_test.go
index 580b87e78dec6a1ac8875830faf411fbad18ef9b..ddd255656f6729940d8940f88d95a48f04b6e5be 100644
--- a/packages/autopeering/discover/manager_test.go
+++ b/packages/autopeering/discover/manager_test.go
@@ -33,7 +33,7 @@ func (m *NetworkMock) discoveryRequest(p *peer.Peer) ([]*peer.Peer, error) {
 }
 
 func newNetworkMock() *NetworkMock {
-	local, _ := peer.NewLocal("mock", "0", peer.NewMemoryDB(logger))
+	local, _ := peer.NewLocal("mock", "0", peer.NewMemoryDB(log))
 	return &NetworkMock{
 		// no database needed
 		loc: local,
@@ -49,7 +49,7 @@ func newDummyPeer(name string) *peer.Peer {
 
 func newTestManager() (*manager, *NetworkMock, func()) {
 	networkMock := newNetworkMock()
-	mgr := newManager(networkMock, nil, logger, nil)
+	mgr := newManager(networkMock, nil, log, nil)
 	teardown := func() {
 		mgr.close()
 	}
diff --git a/packages/autopeering/discover/protocol_test.go b/packages/autopeering/discover/protocol_test.go
index 5de6c010b5754808255e831c03bde9a791502cda..f7c5d328eb50fa27b77f030a4a9589f8fe3b9337 100644
--- a/packages/autopeering/discover/protocol_test.go
+++ b/packages/autopeering/discover/protocol_test.go
@@ -1,7 +1,6 @@
 package discover
 
 import (
-	"log"
 	"testing"
 	"time"
 
@@ -9,6 +8,7 @@ import (
 	"github.com/iotaledger/goshimmer/packages/autopeering/peer/service"
 	"github.com/iotaledger/goshimmer/packages/autopeering/server"
 	"github.com/iotaledger/goshimmer/packages/autopeering/transport"
+	"github.com/iotaledger/hive.go/logger"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/zap"
@@ -16,15 +16,9 @@ import (
 
 const graceTime = 100 * time.Millisecond
 
-var logger *zap.SugaredLogger
+var log = logger.NewExampleLogger("discover")
 
 func init() {
-	l, err := zap.NewDevelopment()
-	if err != nil {
-		log.Fatalf("cannot initialize logger: %v", err)
-	}
-	logger = l.Sugar()
-
 	// decrease parameters to simplify and speed up tests
 	reverifyInterval = 500 * time.Millisecond
 	queryInterval = 1000 * time.Millisecond
@@ -33,7 +27,7 @@ func init() {
 }
 
 // newTest creates a new discovery server and also returns the teardown.
-func newTest(t require.TestingT, trans transport.Transport, logger *zap.SugaredLogger, masters ...*peer.Peer) (*server.Server, *Protocol, func()) {
+func newTest(t require.TestingT, trans transport.Transport, logger *logger.Logger, masters ...*peer.Peer) (*server.Server, *Protocol, func()) {
 	log := logger.Named(trans.LocalAddr().String())
 	db := peer.NewMemoryDB(log.Named("db"))
 	local, err := peer.NewLocal(trans.LocalAddr().Network(), trans.LocalAddr().String(), db)
@@ -63,12 +57,12 @@ func TestProtVerifyMaster(t *testing.T) {
 	p2p := transport.P2P()
 	defer p2p.Close()
 
-	srvA, _, closeA := newTest(t, p2p.A, logger)
+	srvA, _, closeA := newTest(t, p2p.A, log)
 	defer closeA()
 	peerA := getPeer(srvA)
 
 	// use peerA as masters peer
-	_, protB, closeB := newTest(t, p2p.B, logger, peerA)
+	_, protB, closeB := newTest(t, p2p.B, log, peerA)
 
 	time.Sleep(graceTime) // wait for the packages to ripple through the network
 	closeB()              // close srvB to avoid race conditions, when asserting
@@ -83,9 +77,9 @@ func TestProtPingPong(t *testing.T) {
 	p2p := transport.P2P()
 	defer p2p.Close()
 
-	srvA, protA, closeA := newTest(t, p2p.A, logger)
+	srvA, protA, closeA := newTest(t, p2p.A, log)
 	defer closeA()
-	srvB, protB, closeB := newTest(t, p2p.B, logger)
+	srvB, protB, closeB := newTest(t, p2p.B, log)
 	defer closeB()
 
 	peerA := getPeer(srvA)
@@ -104,9 +98,9 @@ func TestProtPingTimeout(t *testing.T) {
 	p2p := transport.P2P()
 	defer p2p.Close()
 
-	_, protA, closeA := newTest(t, p2p.A, logger)
+	_, protA, closeA := newTest(t, p2p.A, log)
 	defer closeA()
-	srvB, _, closeB := newTest(t, p2p.B, logger)
+	srvB, _, closeB := newTest(t, p2p.B, log)
 	closeB() // close the connection right away to prevent any replies
 
 	peerB := getPeer(srvB)
@@ -120,9 +114,9 @@ func TestProtVerifiedPeers(t *testing.T) {
 	p2p := transport.P2P()
 	defer p2p.Close()
 
-	_, protA, closeA := newTest(t, p2p.A, logger)
+	_, protA, closeA := newTest(t, p2p.A, log)
 	defer closeA()
-	srvB, _, closeB := newTest(t, p2p.B, logger)
+	srvB, _, closeB := newTest(t, p2p.B, log)
 	defer closeB()
 
 	peerB := getPeer(srvB)
@@ -142,9 +136,9 @@ func TestProtVerifiedPeer(t *testing.T) {
 	p2p := transport.P2P()
 	defer p2p.Close()
 
-	srvA, protA, closeA := newTest(t, p2p.A, logger)
+	srvA, protA, closeA := newTest(t, p2p.A, log)
 	defer closeA()
-	srvB, _, closeB := newTest(t, p2p.B, logger)
+	srvB, _, closeB := newTest(t, p2p.B, log)
 	defer closeB()
 
 	peerA := getPeer(srvA)
@@ -166,9 +160,9 @@ func TestProtDiscoveryRequest(t *testing.T) {
 	p2p := transport.P2P()
 	defer p2p.Close()
 
-	srvA, protA, closeA := newTest(t, p2p.A, logger)
+	srvA, protA, closeA := newTest(t, p2p.A, log)
 	defer closeA()
-	srvB, protB, closeB := newTest(t, p2p.B, logger)
+	srvB, protB, closeB := newTest(t, p2p.B, log)
 	defer closeB()
 
 	peerA := getPeer(srvA)
@@ -192,13 +186,13 @@ func TestProtServices(t *testing.T) {
 	p2p := transport.P2P()
 	defer p2p.Close()
 
-	srvA, _, closeA := newTest(t, p2p.A, logger)
+	srvA, _, closeA := newTest(t, p2p.A, log)
 	defer closeA()
 	err := srvA.Local().UpdateService(service.FPCKey, "fpc", p2p.A.LocalAddr().String())
 	require.NoError(t, err)
 
 	// use peerA as masters peer
-	_, protB, closeB := newTest(t, p2p.B, logger, getPeer(srvA))
+	_, protB, closeB := newTest(t, p2p.B, log, getPeer(srvA))
 	defer closeB()
 
 	time.Sleep(graceTime) // wait for the packages to ripple through the network
@@ -213,15 +207,15 @@ func TestProtDiscovery(t *testing.T) {
 	net := transport.NewNetwork("M", "A", "B", "C")
 	defer net.Close()
 
-	srvM, protM, closeM := newTest(t, net.GetTransport("M"), logger)
+	srvM, protM, closeM := newTest(t, net.GetTransport("M"), log)
 	defer closeM()
 	time.Sleep(graceTime) // wait for the master to initialize
 
-	srvA, protA, closeA := newTest(t, net.GetTransport("A"), logger, getPeer(srvM))
+	srvA, protA, closeA := newTest(t, net.GetTransport("A"), log, getPeer(srvM))
 	defer closeA()
-	srvB, protB, closeB := newTest(t, net.GetTransport("B"), logger, getPeer(srvM))
+	srvB, protB, closeB := newTest(t, net.GetTransport("B"), log, getPeer(srvM))
 	defer closeB()
-	srvC, protC, closeC := newTest(t, net.GetTransport("C"), logger, getPeer(srvM))
+	srvC, protC, closeC := newTest(t, net.GetTransport("C"), log, getPeer(srvM))
 	defer closeC()
 
 	time.Sleep(queryInterval + graceTime)    // wait for the next discovery cycle
diff --git a/packages/autopeering/selection/manager_test.go b/packages/autopeering/selection/manager_test.go
index 8c3939d8fc8252e03cadeb0cac5956f212f6a21f..daffe4b0ae8746e35ed4adc981e5c3d70be8056f 100644
--- a/packages/autopeering/selection/manager_test.go
+++ b/packages/autopeering/selection/manager_test.go
@@ -2,15 +2,14 @@ package selection
 
 import (
 	"fmt"
-	"log"
 	"math/rand"
 	"testing"
 	"time"
 
 	"github.com/iotaledger/goshimmer/packages/autopeering/peer"
 	"github.com/iotaledger/goshimmer/packages/autopeering/salt"
+	"github.com/iotaledger/hive.go/logger"
 	"github.com/stretchr/testify/assert"
-	"go.uber.org/zap"
 )
 
 var (
@@ -21,23 +20,12 @@ type testPeer struct {
 	local *peer.Local
 	peer  *peer.Peer
 	db    peer.DB
-	log   *zap.SugaredLogger
+	log   *logger.Logger
 	rand  *rand.Rand // random number generator
 }
 
 func newPeer(name string) testPeer {
-	var l *zap.Logger
-	var err error
-	if name == "1" {
-		l, err = zap.NewDevelopment()
-	} else {
-		l, err = zap.NewDevelopment() //zap.NewProduction()
-	}
-	if err != nil {
-		log.Fatalf("cannot initialize logger: %v", err)
-	}
-	logger := l.Sugar()
-	log := logger.Named(name)
+	log := log.Named(name)
 	db := peer.NewMemoryDB(log.Named("db"))
 	local, _ := peer.NewLocal("", name, db)
 	s, _ := salt.NewSalt(100 * time.Second)
@@ -84,12 +72,12 @@ func (n testNet) RequestPeering(p *peer.Peer, s *salt.Salt) (bool, error) {
 func (n testNet) GetKnownPeers() []*peer.Peer {
 	list := make([]*peer.Peer, len(allPeers)-1)
 	i := 0
-	for _, peer := range allPeers {
-		if peer.ID() == n.self.ID() {
+	for _, p := range allPeers {
+		if p.ID() == n.self.ID() {
 			continue
 		}
 
-		list[i] = peer
+		list[i] = p
 		i++
 	}
 	return list
@@ -102,16 +90,16 @@ func TestSimManager(t *testing.T) {
 
 	mgrMap := make(map[peer.ID]*manager)
 	for i := range allPeers {
-		peer := newPeer(fmt.Sprintf("%d", i))
-		allPeers[i] = peer.peer
+		p := newPeer(fmt.Sprintf("%d", i))
+		allPeers[i] = p.peer
 
 		net := testNet{
 			mgr:  mgrMap,
-			loc:  peer.local,
-			self: peer.peer,
-			rand: peer.rand,
+			loc:  p.local,
+			self: p.peer,
+			rand: p.rand,
 		}
-		mgrMap[peer.local.ID()] = newManager(net, net.GetKnownPeers, peer.log, &Parameters{SaltLifetime: 100 * time.Second})
+		mgrMap[p.local.ID()] = newManager(net, net.GetKnownPeers, p.log, &Parameters{SaltLifetime: 100 * time.Second})
 	}
 
 	// start all the managers
@@ -121,8 +109,8 @@ func TestSimManager(t *testing.T) {
 
 	time.Sleep(6 * time.Second)
 
-	for i, peer := range allPeers {
-		neighbors := mgrMap[peer.ID()].getNeighbors()
+	for i, p := range allPeers {
+		neighbors := mgrMap[p.ID()].getNeighbors()
 
 		assert.NotEmpty(t, neighbors, "Peer %d has no neighbors", i)
 		assert.Equal(t, removeDuplicatePeers(neighbors), neighbors, "Peer %d has non unique neighbors", i)
diff --git a/packages/autopeering/selection/protocol_test.go b/packages/autopeering/selection/protocol_test.go
index 2d3a1295823c47360dbd4b9221311beb29c2888d..37871352ff1f04fd004123684783121ef7ad57c6 100644
--- a/packages/autopeering/selection/protocol_test.go
+++ b/packages/autopeering/selection/protocol_test.go
@@ -1,7 +1,6 @@
 package selection
 
 import (
-	"log"
 	"testing"
 	"time"
 
@@ -10,36 +9,28 @@ import (
 	"github.com/iotaledger/goshimmer/packages/autopeering/salt"
 	"github.com/iotaledger/goshimmer/packages/autopeering/server"
 	"github.com/iotaledger/goshimmer/packages/autopeering/transport"
+	"github.com/iotaledger/hive.go/logger"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"go.uber.org/zap"
 )
 
 const graceTime = 100 * time.Millisecond
 
-var logger *zap.SugaredLogger
-
-func init() {
-	l, err := zap.NewDevelopment()
-	if err != nil {
-		log.Fatalf("cannot initialize logger: %v", err)
-	}
-	logger = l.Sugar()
-}
+var log = logger.NewExampleLogger("selection")
 
 var peerMap = make(map[peer.ID]*peer.Peer)
 
 // dummyDiscovery is a dummy implementation of DiscoveryProtocol never returning any verified peers.
 type dummyDiscovery struct{}
 
-func (d dummyDiscovery) IsVerified(peer.ID, string) bool                    { return true }
-func (d dummyDiscovery) EnsureVerified(*peer.Peer)                          {}
-func (d dummyDiscovery) GetVerifiedPeer(id peer.ID, addr string) *peer.Peer { return peerMap[id] }
-func (d dummyDiscovery) GetVerifiedPeers() []*peer.Peer                     { return []*peer.Peer{} }
+func (d dummyDiscovery) IsVerified(peer.ID, string) bool                 { return true }
+func (d dummyDiscovery) EnsureVerified(*peer.Peer)                       {}
+func (d dummyDiscovery) GetVerifiedPeer(id peer.ID, _ string) *peer.Peer { return peerMap[id] }
+func (d dummyDiscovery) GetVerifiedPeers() []*peer.Peer                  { return []*peer.Peer{} }
 
 // newTest creates a new neighborhood server and also returns the teardown.
-func newTest(t require.TestingT, trans transport.Transport, logger *zap.SugaredLogger) (*server.Server, *Protocol, func()) {
-	log := logger.Named(trans.LocalAddr().String())
+func newTest(t require.TestingT, trans transport.Transport) (*server.Server, *Protocol, func()) {
+	log := log.Named(trans.LocalAddr().String())
 	db := peer.NewMemoryDB(log.Named("db"))
 	local, err := peer.NewLocal(trans.LocalAddr().Network(), trans.LocalAddr().String(), db)
 	require.NoError(t, err)
@@ -70,9 +61,9 @@ func TestProtPeeringRequest(t *testing.T) {
 	p2p := transport.P2P()
 	defer p2p.Close()
 
-	srvA, protA, closeA := newTest(t, p2p.A, logger)
+	srvA, protA, closeA := newTest(t, p2p.A)
 	defer closeA()
-	srvB, protB, closeB := newTest(t, p2p.B, logger)
+	srvB, protB, closeB := newTest(t, p2p.B)
 	defer closeB()
 
 	peerA := getPeer(srvA)
@@ -98,9 +89,9 @@ func TestProtExpiredSalt(t *testing.T) {
 	p2p := transport.P2P()
 	defer p2p.Close()
 
-	_, protA, closeA := newTest(t, p2p.A, logger)
+	_, protA, closeA := newTest(t, p2p.A)
 	defer closeA()
-	srvB, _, closeB := newTest(t, p2p.B, logger)
+	srvB, _, closeB := newTest(t, p2p.B)
 	defer closeB()
 
 	saltA, _ := salt.NewSalt(-1 * time.Second)
@@ -115,9 +106,9 @@ func TestProtDropPeer(t *testing.T) {
 	p2p := transport.P2P()
 	defer p2p.Close()
 
-	srvA, protA, closeA := newTest(t, p2p.A, logger)
+	srvA, protA, closeA := newTest(t, p2p.A)
 	defer closeA()
-	srvB, protB, closeB := newTest(t, p2p.B, logger)
+	srvB, protB, closeB := newTest(t, p2p.B)
 	defer closeB()
 
 	peerA := getPeer(srvA)
@@ -139,7 +130,7 @@ func TestProtDropPeer(t *testing.T) {
 
 // newTest creates a new server handling discover as well as neighborhood and also returns the teardown.
 func newFullTest(t require.TestingT, trans transport.Transport, masterPeers ...*peer.Peer) (*server.Server, *Protocol, func()) {
-	log := logger.Named(trans.LocalAddr().String())
+	log := log.Named(trans.LocalAddr().String())
 	db := peer.NewMemoryDB(log.Named("db"))
 	local, err := peer.NewLocal(trans.LocalAddr().Network(), trans.LocalAddr().String(), db)
 	require.NoError(t, err)
diff --git a/packages/autopeering/server/server_test.go b/packages/autopeering/server/server_test.go
index 80f36274731b938f3aab3351eee00b948810101c..3e784af58486beb90a420f98c4ff68c6e020b8e7 100644
--- a/packages/autopeering/server/server_test.go
+++ b/packages/autopeering/server/server_test.go
@@ -1,30 +1,21 @@
 package server
 
 import (
-	"log"
 	"testing"
 	"time"
 
 	"github.com/iotaledger/goshimmer/packages/autopeering/peer"
 	"github.com/iotaledger/goshimmer/packages/autopeering/salt"
 	"github.com/iotaledger/goshimmer/packages/autopeering/transport"
+	"github.com/iotaledger/hive.go/logger"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
-	"go.uber.org/zap"
 )
 
 const graceTime = 5 * time.Millisecond
 
-var logger *zap.SugaredLogger
-
-func init() {
-	l, err := zap.NewDevelopment()
-	if err != nil {
-		log.Fatalf("cannot initialize logger: %v", err)
-	}
-	logger = l.Sugar()
-}
+var log = logger.NewExampleLogger("server")
 
 const (
 	MPing MType = iota
@@ -106,7 +97,7 @@ func unmarshal(data []byte) (Message, error) {
 
 func TestSrvEncodeDecodePing(t *testing.T) {
 	// create minimal server just containing the local peer
-	local, err := peer.NewLocal("dummy", "local", peer.NewMemoryDB(logger))
+	local, err := peer.NewLocal("dummy", "local", peer.NewMemoryDB(log))
 	require.NoError(t, err)
 	s := &Server{local: local}
 
@@ -121,8 +112,8 @@ func TestSrvEncodeDecodePing(t *testing.T) {
 	assert.Equal(t, msg, ping)
 }
 
-func newTestServer(t require.TestingT, name string, trans transport.Transport, logger *zap.SugaredLogger) (*Server, func()) {
-	log := logger.Named(name)
+func newTestServer(t require.TestingT, name string, trans transport.Transport) (*Server, func()) {
+	log := log.Named(name)
 	db := peer.NewMemoryDB(log.Named("db"))
 	local, err := peer.NewLocal(trans.LocalAddr().Network(), trans.LocalAddr().String(), db)
 	require.NoError(t, err)
@@ -132,7 +123,7 @@ func newTestServer(t require.TestingT, name string, trans transport.Transport, l
 	s, _ = salt.NewSalt(100 * time.Second)
 	local.SetPublicSalt(s)
 
-	srv := Listen(local, trans, logger.Named(name), HandlerFunc(handle))
+	srv := Listen(local, trans, log, HandlerFunc(handle))
 
 	teardown := func() {
 		srv.Close()
@@ -155,9 +146,9 @@ func sendPing(s *Server, p *peer.Peer) error {
 func TestPingPong(t *testing.T) {
 	p2p := transport.P2P()
 
-	srvA, closeA := newTestServer(t, "A", p2p.A, logger)
+	srvA, closeA := newTestServer(t, "A", p2p.A)
 	defer closeA()
-	srvB, closeB := newTestServer(t, "B", p2p.B, logger)
+	srvB, closeB := newTestServer(t, "B", p2p.B)
 	defer closeB()
 
 	peerA := &srvA.Local().Peer
@@ -192,9 +183,9 @@ func TestSrvPingTimeout(t *testing.T) {
 
 	p2p := transport.P2P()
 
-	srvA, closeA := newTestServer(t, "A", p2p.A, logger)
+	srvA, closeA := newTestServer(t, "A", p2p.A)
 	defer closeA()
-	srvB, closeB := newTestServer(t, "B", p2p.B, logger)
+	srvB, closeB := newTestServer(t, "B", p2p.B)
 	closeB()
 
 	peerB := &srvB.Local().Peer
@@ -206,9 +197,9 @@ func TestUnexpectedPong(t *testing.T) {
 
 	p2p := transport.P2P()
 
-	srvA, closeA := newTestServer(t, "A", p2p.A, logger)
+	srvA, closeA := newTestServer(t, "A", p2p.A)
 	defer closeA()
-	srvB, closeB := newTestServer(t, "B", p2p.B, logger)
+	srvB, closeB := newTestServer(t, "B", p2p.B)
 	defer closeB()
 
 	// there should never be a Ping.Handle