diff --git a/Blockchain Cache Global.go b/Blockchain Cache Global.go
index fa708d7..d3f0048 100644
--- a/Blockchain Cache Global.go	
+++ b/Blockchain Cache Global.go	
@@ -42,7 +42,7 @@ func (backend *Backend) initBlockchainCache() {
 	var err error
 	backend.GlobalBlockchainCache.Store, err = blockchain.InitMultiStore(backend.Config.BlockchainGlobal)
 	if err != nil {
-		backend.Filters.LogError("initBlockchainCache", "initializing database '%s': %s", backend.Config.BlockchainGlobal, err.Error())
+		backend.LogError("initBlockchainCache", "initializing database '%s': %s", backend.Config.BlockchainGlobal, err.Error())
 		return
 	}
 
diff --git a/Blockchain User.go b/Blockchain User.go
index f10559a..de6f64a 100644
--- a/Blockchain User.go	
+++ b/Blockchain User.go	
@@ -21,7 +21,7 @@ func (backend *Backend) initUserBlockchain() {
 	backend.UserBlockchain, err = blockchain.Init(backend.peerPrivateKey, backend.Config.BlockchainMain)
 
 	if err != nil {
-		backend.Filters.LogError("initUserBlockchain", "error: %s\n", err.Error())
+		backend.LogError("initUserBlockchain", "error: %s\n", err.Error())
 		os.Exit(ExitBlockchainCorrupt)
 	}
 }
diff --git a/Bootstrap.go b/Bootstrap.go
index 67e77f9..664926a 100644
--- a/Bootstrap.go
+++ b/Bootstrap.go
@@ -47,12 +47,12 @@ loopSeedList:
 		// parse the Public Key
 		publicKeyB, err := hex.DecodeString(seed.PublicKey)
 		if err != nil {
-			backend.Filters.LogError("initSeedList", "public key '%s': %v\n", seed.PublicKey, err.Error())
+			backend.LogError("initSeedList", "public key '%s': %v\n", seed.PublicKey, err.Error())
 			continue
 		}
 
 		if peer.publicKey, err = btcec.ParsePubKey(publicKeyB, btcec.S256()); err != nil {
-			backend.Filters.LogError("initSeedList", "public key '%s': %v\n", seed.PublicKey, err.Error())
+			backend.LogError("initSeedList", "public key '%s': %v\n", seed.PublicKey, err.Error())
 			continue
 		}
 
@@ -64,7 +64,7 @@ loopSeedList:
 		for _, addressA := range seed.Address {
 			address, err := parseAddress(addressA)
 			if err != nil {
-				backend.Filters.LogError("initSeedList", "public key '%s' address '%s': %v\n", seed.PublicKey, addressA, err.Error())
+				backend.LogError("initSeedList", "public key '%s' address '%s': %v\n", seed.PublicKey, addressA, err.Error())
 				continue loopSeedList
 			}
 
@@ -115,7 +115,7 @@ func (backend *Backend) bootstrap() {
 	go resetRecentContacts()
 
 	if len(rootPeers) == 0 {
-		backend.Filters.LogError("bootstrap", "warning: Empty list of root peers. Connectivity relies on local peer discovery and incoming connections.\n")
+		backend.LogError("bootstrap", "warning: Empty list of root peers. Connectivity relies on local peer discovery and incoming connections.\n")
 		return
 	}
 
@@ -163,7 +163,7 @@ func (backend *Backend) bootstrap() {
 		}
 	}
 
-	backend.Filters.LogError("bootstrap", "unable to connect to at least 2 root peers, aborting\n")
+	backend.LogError("bootstrap", "unable to connect to at least 2 root peers, aborting\n")
 }
 
 func (nets *Networks) autoMulticastBroadcast() {
@@ -173,13 +173,13 @@ func (nets *Networks) autoMulticastBroadcast() {
 
 		for _, network := range nets.networks6 {
 			if err := network.MulticastIPv6Send(); err != nil {
-				nets.backend.Filters.LogError("autoMulticastBroadcast", "multicast from network address '%s': %v\n", network.address.IP.String(), err.Error())
+				nets.backend.LogError("autoMulticastBroadcast", "multicast from network address '%s': %v\n", network.address.IP.String(), err.Error())
 			}
 		}
 
 		for _, network := range nets.networks4 {
 			if err := network.BroadcastIPv4Send(); err != nil {
-				nets.backend.Filters.LogError("autoMulticastBroadcast", "broadcast from network address '%s': %v\n", network.address.IP.String(), err.Error())
+				nets.backend.LogError("autoMulticastBroadcast", "broadcast from network address '%s': %v\n", network.address.IP.String(), err.Error())
 			}
 		}
 	}
diff --git a/Commands.go b/Commands.go
index 9a7b413..bedc666 100644
--- a/Commands.go
+++ b/Commands.go
@@ -145,7 +145,7 @@ func (peer *PeerInfo) cmdResponse(msg *protocol.MessageResponse, connection *Con
 	if msg.SequenceInfo == nil || msg.SequenceInfo.Data == nil {
 		// If there is no sequence data but there were results returned, it means we received unsolicited response data. It will be rejected.
 		if len(msg.HashesNotFound) > 0 || len(msg.Hash2Peers) > 0 || len(msg.FilesEmbed) > 0 {
-			peer.Backend.Filters.LogError("cmdResponse", "unsolicited response data received from %s\n", connection.Address.String())
+			peer.Backend.LogError("cmdResponse", "unsolicited response data received from %s\n", connection.Address.String())
 		}
 
 		return
@@ -156,7 +156,7 @@ func (peer *PeerInfo) cmdResponse(msg *protocol.MessageResponse, connection *Con
 		for _, hash2Peer := range msg.Hash2Peers {
 			// Make sure no garbage is returned. The key must be self and only Closest is expected.
 			if !bytes.Equal(hash2Peer.ID.Hash, peer.Backend.nodeID) || len(hash2Peer.Closest) == 0 {
-				peer.Backend.Filters.LogError("cmdResponse", "incoming response to bootstrap FIND_SELF contains invalid data from %s\n", connection.Address.String())
+				peer.Backend.LogError("cmdResponse", "incoming response to bootstrap FIND_SELF contains invalid data from %s\n", connection.Address.String())
 				return
 			}
 
@@ -224,7 +224,7 @@ func (peer *PeerInfo) cmdLocalDiscovery(msg *protocol.MessageAnnouncement, conne
 	// only accept local discovery message from private IPs for IPv4
 	// IPv6 DHCP routers typically assign public IPv6s and they can join multicast in the local network.
 	//if connection.IsIPv4() && !connection.IsLocal() {
-	//	Filters.LogError("cmdLocalDiscovery", "message received from non-local IP %s peer ID %s\n", connection.Address.String(), hex.EncodeToString(msg.SenderPublicKey.SerializeCompressed()))
+	//	LogError("cmdLocalDiscovery", "message received from non-local IP %s peer ID %s\n", connection.Address.String(), hex.EncodeToString(msg.SenderPublicKey.SerializeCompressed()))
 	//	return
 	//}
 
diff --git a/Config.go b/Config.go
index 18fdb21..ec70526 100644
--- a/Config.go
+++ b/Config.go
@@ -8,6 +8,7 @@ package core
 
 import (
 	_ "embed" // Required for embedding default Config file
+	"fmt"
 	"io/ioutil"
 	"log"
 	"os"
@@ -29,6 +30,9 @@ type Config struct {
 	SearchIndex      string `yaml:"SearchIndex"`      // Local search index of blockchain records. Empty to disable.
 	GeoIPDatabase    string `yaml:"GeoIPDatabase"`    // GeoLite2 City database to provide GeoIP information.
 
+	// Target for the log messages: 0 = Log file,  1 = Stdout, 2 = Log file + Stdout, 3 = None
+	LogTarget int `yaml:"LogTarget"`
+
 	// Listen settings
 	Listen        []string `yaml:"Listen"`        // IP:Port combinations
 	ListenWorkers int      `yaml:"ListenWorkers"` // Count of workers to process incoming raw packets. Default 2.
@@ -102,7 +106,7 @@ func SaveConfig(Filename string, Config interface{}) (err error) {
 // SaveConfig stores the current runtime config to file. Any foreign settings not present in the Config structure will be deleted.
 func (backend *Backend) SaveConfig() {
 	if err := SaveConfig(backend.ConfigFilename, *backend.Config); err != nil {
-		backend.Filters.LogError("SaveConfig", "writing config '%s': %v\n", backend.ConfigFilename, err.Error())
+		backend.LogError("SaveConfig", "writing config '%s': %v\n", backend.ConfigFilename, err.Error())
 	}
 }
 
@@ -139,3 +143,23 @@ func (backend *Backend) initLog() (err error) {
 
 	return nil
 }
+
+// Logs an error message.
+func (backend *Backend) LogError(function, format string, v ...interface{}) {
+	switch backend.Config.LogTarget {
+	case 0:
+		log.Printf("["+function+"] "+format, v...)
+
+	case 1:
+		fmt.Fprintf(backend.Stdout, "["+function+"] "+format, v...)
+
+	case 2:
+		log.Printf("["+function+"] "+format, v...)
+
+		fmt.Fprintf(backend.Stdout, "["+function+"] "+format, v...)
+
+	case 3: // None
+	}
+
+	backend.Filters.LogError(function, format, v)
+}
diff --git a/Filter.go b/Filter.go
index cd69e85..e825b8b 100644
--- a/Filter.go
+++ b/Filter.go
@@ -10,7 +10,6 @@ package core
 
 import (
 	"io"
-	"log"
 	"sync"
 
 	"github.com/PeernetOfficial/core/blockchain"
@@ -31,7 +30,7 @@ type Filters struct {
 	// NewPeerConnection is called for each new established connection to a peer. Note that connections might be dropped and reconnected at anytime.
 	NewPeerConnection func(peer *PeerInfo, connection *Connection)
 
-	// LogError is called for any error. If this function is overwritten by the caller, the caller must write errors into the log file if desired, or call DefaultLogError.
+	// LogError is called for any error.
 	LogError func(function, format string, v ...interface{})
 
 	// DHTSearchStatus is called with updates of searches in the DHT. It allows to see the live progress of searches.
@@ -88,7 +87,7 @@ func (backend *Backend) initFilters() {
 		backend.Filters.DHTSearchStatus = func(client *dht.SearchClient, function, format string, v ...interface{}) {}
 	}
 	if backend.Filters.LogError == nil {
-		backend.Filters.LogError = DefaultLogError
+		backend.Filters.LogError = func(function, format string, v ...interface{}) {}
 	}
 	if backend.Filters.IncomingRequest == nil {
 		backend.Filters.IncomingRequest = func(peer *PeerInfo, Action int, Key []byte, Info interface{}) {}
@@ -122,11 +121,6 @@ func (backend *Backend) initFilters() {
 	}
 }
 
-// DefaultLogError is the default error logging function
-func DefaultLogError(function, format string, v ...interface{}) {
-	log.Printf("["+function+"] "+format, v...)
-}
-
 // MultiWriter code that allows to subscribe/unsubscribe.
 type multiWriter struct {
 	writers map[uuid.UUID]io.Writer
diff --git a/Network Detection.go b/Network Detection.go
index 776a1d2..6c80b81 100644
--- a/Network Detection.go	
+++ b/Network Detection.go	
@@ -104,7 +104,7 @@ func (nets *Networks) networkChangeMonitor() {
 
 		interfaceList, err := net.Interfaces()
 		if err != nil {
-			nets.backend.Filters.LogError("networkChangeMonitor", "enumerating network adapters failed: %s\n", err.Error())
+			nets.backend.LogError("networkChangeMonitor", "enumerating network adapters failed: %s\n", err.Error())
 			continue
 		}
 
@@ -113,7 +113,7 @@ func (nets *Networks) networkChangeMonitor() {
 		for _, iface := range interfaceList {
 			addressesNew, err := iface.Addrs()
 			if err != nil {
-				nets.backend.Filters.LogError("networkChangeMonitor", "enumerating IPs for network adapter '%s': %s\n", iface.Name, err.Error())
+				nets.backend.LogError("networkChangeMonitor", "enumerating IPs for network adapter '%s': %s\n", iface.Name, err.Error())
 				continue
 			}
 			ifacesNew[iface.Name] = addressesNew
@@ -168,7 +168,7 @@ func (nets *Networks) networkChangeMonitor() {
 
 // networkChangeInterfaceNew is called when a new interface is detected
 func (nets *Networks) networkChangeInterfaceNew(iface net.Interface, addresses []net.Addr) {
-	nets.backend.Filters.LogError("networkChangeInterfaceNew", "new interface '%s' (%d IPs)\n", iface.Name, len(addresses))
+	nets.backend.LogError("networkChangeInterfaceNew", "new interface '%s' (%d IPs)\n", iface.Name, len(addresses))
 
 	networksNew := nets.InterfaceStart(iface, addresses)
 
@@ -184,7 +184,7 @@ func (nets *Networks) networkChangeInterfaceRemove(iface string, addresses []net
 	nets.RLock()
 	defer nets.RUnlock()
 
-	nets.backend.Filters.LogError("networkChangeInterfaceRemove", "removing interface '%s' (%d IPs)\n", iface, len(addresses))
+	nets.backend.LogError("networkChangeInterfaceRemove", "removing interface '%s' (%d IPs)\n", iface, len(addresses))
 
 	for n, network := range nets.networks6 {
 		if network.iface != nil && network.iface.Name == iface {
@@ -215,7 +215,7 @@ func (nets *Networks) networkChangeInterfaceRemove(iface string, addresses []net
 
 // networkChangeIPNew is called when an existing interface lists a new IP
 func (nets *Networks) networkChangeIPNew(iface net.Interface, address net.Addr) {
-	nets.backend.Filters.LogError("networkChangeIPNew", "new interface '%s' IP %s\n", iface.Name, address.String())
+	nets.backend.LogError("networkChangeIPNew", "new interface '%s' IP %s\n", iface.Name, address.String())
 
 	networksNew := nets.InterfaceStart(iface, []net.Addr{address})
 
@@ -231,7 +231,7 @@ func (nets *Networks) networkChangeIPRemove(iface net.Interface, address net.Add
 	nets.RLock()
 	defer nets.RUnlock()
 
-	nets.backend.Filters.LogError("networkChangeIPRemove", "remove interface '%s' IP %s\n", iface.Name, address.String())
+	nets.backend.LogError("networkChangeIPRemove", "remove interface '%s' IP %s\n", iface.Name, address.String())
 
 	for n, network := range nets.networks6 {
 		if network.address.IP.Equal(address.(*net.IPNet).IP) {
diff --git a/Network IPv4 Broadcast.go b/Network IPv4 Broadcast.go
index 33414da..b95bf45 100644
--- a/Network IPv4 Broadcast.go	
+++ b/Network IPv4 Broadcast.go	
@@ -43,7 +43,7 @@ func (network *Network) BroadcastIPv4() (err error) {
 	// listen on a special socket
 	network.broadcastSocket, err = reuseport.ListenPacket("udp4", net.JoinHostPort(network.address.IP.String(), strconv.Itoa(ipv4BroadcastPort)))
 	if err != nil {
-		network.backend.Filters.LogError("BroadcastIPv4", "broadcast socket listen on IP '%s' port '%d': %v\n", network.address.IP.String(), ipv4BroadcastPort, err)
+		network.backend.LogError("BroadcastIPv4", "broadcast socket listen on IP '%s' port '%d': %v\n", network.address.IP.String(), ipv4BroadcastPort, err)
 		return err
 	}
 
@@ -64,8 +64,8 @@ func (network *Network) BroadcastIPv4Listen() {
 		length, sender, err := network.broadcastSocket.ReadFrom(buffer)
 
 		if err != nil {
-			network.backend.Filters.LogError("BroadcastIPv4Listen", "receiving UDP message: %v\n", err) // Only log for debug purposes.
-			time.Sleep(time.Millisecond * 50)                                                           // In case of endless errors, prevent ddos of CPU.
+			network.backend.LogError("BroadcastIPv4Listen", "receiving UDP message: %v\n", err) // Only log for debug purposes.
+			time.Sleep(time.Millisecond * 50)                                                   // In case of endless errors, prevent ddos of CPU.
 			continue
 		}
 
@@ -107,7 +107,7 @@ func (network *Network) BroadcastIPv4Send() (err error) {
 	for _, ip := range network.broadcastIPv4 {
 		err = network.send(ip, ipv4BroadcastPort, raw)
 		if err != nil {
-			network.backend.Filters.LogError("BroadcastIPv4Send", "sending UDP packet: %v\n", err)
+			network.backend.LogError("BroadcastIPv4Send", "sending UDP packet: %v\n", err)
 		}
 	}
 
diff --git a/Network IPv6 Multicast.go b/Network IPv6 Multicast.go
index b5c6cd8..b206639 100644
--- a/Network IPv6 Multicast.go	
+++ b/Network IPv6 Multicast.go	
@@ -56,21 +56,21 @@ func (network *Network) MulticastIPv6Join() (err error) {
 	// listen on a special socket
 	network.multicastSocket, err = reuseport.ListenPacket("udp6", net.JoinHostPort(network.address.IP.String(), strconv.Itoa(ipv6MulticastPort)))
 	if err != nil {
-		network.backend.Filters.LogError("MulticastIPv6Join", "multicast socket listen on IP '%s' port '%d': %v\n", network.address.IP.String(), ipv6MulticastPort, err)
+		network.backend.LogError("MulticastIPv6Join", "multicast socket listen on IP '%s' port '%d': %v\n", network.address.IP.String(), ipv6MulticastPort, err)
 		return err
 	}
 
 	joinMulticastGroup := func(iface *net.Interface) (err error) {
 		pc := ipv6.NewPacketConn(network.multicastSocket)
 		if err := pc.JoinGroup(iface, &net.UDPAddr{IP: network.multicastIP}); err != nil {
-			//Filters.LogError("MulticastIPv6Join", "join multicast group iface '%s' multicast IP '%s' listen on IP '%s' port '%d': %v\n", iface.Name, network.multicastIP.String(), network.address.IP.String(), ipv6MulticastPort, err)
+			//LogError("MulticastIPv6Join", "join multicast group iface '%s' multicast IP '%s' listen on IP '%s' port '%d': %v\n", iface.Name, network.multicastIP.String(), network.address.IP.String(), ipv6MulticastPort, err)
 			return err
 		}
 
 		// receive messages from self or other processes running on the same computer
 		if loop, err := pc.MulticastLoopback(); err == nil && !loop {
 			if err := pc.SetMulticastLoopback(true); err != nil {
-				network.backend.Filters.LogError("MulticastIPv6Join", "setting multicast loopback status: %v\n", err)
+				network.backend.LogError("MulticastIPv6Join", "setting multicast loopback status: %v\n", err)
 			}
 		}
 
@@ -108,8 +108,8 @@ func (network *Network) MulticastIPv6Listen() {
 		length, sender, err := network.multicastSocket.ReadFrom(buffer)
 
 		if err != nil {
-			network.backend.Filters.LogError("MulticastIPv6Listen", "receiving UDP message: %v\n", err) // Only log for debug purposes.
-			time.Sleep(time.Millisecond * 50)                                                           // In case of endless errors, prevent ddos of CPU.
+			network.backend.LogError("MulticastIPv6Listen", "receiving UDP message: %v\n", err) // Only log for debug purposes.
+			time.Sleep(time.Millisecond * 50)                                                   // In case of endless errors, prevent ddos of CPU.
 			continue
 		}
 
diff --git a/Network Init.go b/Network Init.go
index 45ff120..a446966 100644
--- a/Network Init.go	
+++ b/Network Init.go	
@@ -50,14 +50,14 @@ func (backend *Backend) initNetwork() {
 				host = listenA
 				portA = "0"
 			} else if err != nil {
-				backend.Filters.LogError("initNetwork", "invalid input listen address '%s': %s\n", listenA, err.Error())
+				backend.LogError("initNetwork", "invalid input listen address '%s': %s\n", listenA, err.Error())
 				continue
 			}
 
 			portI, _ := strconv.Atoi(portA)
 
 			if _, err := backend.networks.PrepareListen(host, portI); err != nil {
-				backend.Filters.LogError("initNetwork", "listen on '%s': %s\n", listenA, err.Error())
+				backend.LogError("initNetwork", "listen on '%s': %s\n", listenA, err.Error())
 				continue
 			}
 		}
@@ -67,10 +67,10 @@ func (backend *Backend) initNetwork() {
 
 	// Listen on all IPv4 and IPv6 addresses
 	//if _, err := networks.PrepareListen("0.0.0.0", 0); err != nil {
-	//	Filters.LogError("initNetwork", "listen on all IPv4 addresses (0.0.0.0): %s\n", err.Error())
+	//	LogError("initNetwork", "listen on all IPv4 addresses (0.0.0.0): %s\n", err.Error())
 	//}
 	//if _, err := networks.PrepareListen("::", 0); err != nil {
-	//	Filters.LogError("initNetwork", "listen on all IPv6 addresses (::): %s\n", err.Error())
+	//	LogError("initNetwork", "listen on all IPv6 addresses (::): %s\n", err.Error())
 	//}
 
 	// Listen on each network adapter on each IP. This guarantees the highest deliverability, even though it brings on additional challenges such as:
@@ -79,14 +79,14 @@ func (backend *Backend) initNetwork() {
 	// * Network adapters and IPs might change. Simplest case is if someone changes Wifi network.
 	interfaceList, err := net.Interfaces()
 	if err != nil {
-		backend.Filters.LogError("initNetwork", "enumerating network adapters failed: %s\n", err.Error())
+		backend.LogError("initNetwork", "enumerating network adapters failed: %s\n", err.Error())
 		return
 	}
 
 	for _, iface := range interfaceList {
 		addresses, err := iface.Addrs()
 		if err != nil {
-			backend.Filters.LogError("initNetwork", "enumerating IPs for network adapter '%s': %s\n", iface.Name, err.Error())
+			backend.LogError("initNetwork", "enumerating IPs for network adapter '%s': %s\n", iface.Name, err.Error())
 			continue
 		}
 
@@ -116,13 +116,13 @@ func (nets *Networks) InterfaceStart(iface net.Interface, addresses []net.Addr)
 				continue
 			}
 
-			nets.backend.Filters.LogError("networks.InterfaceStart", "listening on network adapter '%s' IPv4 '%s': %s\n", iface.Name, net1.IP.String(), err.Error())
+			nets.backend.LogError("networks.InterfaceStart", "listening on network adapter '%s' IPv4 '%s': %s\n", iface.Name, net1.IP.String(), err.Error())
 			continue
 		}
 
 		nets.ipListen.Add(networkNew.address)
 
-		nets.backend.Filters.LogError("networks.InterfaceStart", "listen on network '%s' UDP %s\n", iface.Name, networkNew.address.String())
+		nets.backend.LogError("networks.InterfaceStart", "listen on network '%s' UDP %s\n", iface.Name, networkNew.address.String())
 
 		networksNew = append(networksNew, networkNew)
 	}
diff --git a/Network UPnP.go b/Network UPnP.go
index cfdc837..9ed331e 100644
--- a/Network UPnP.go	
+++ b/Network UPnP.go	
@@ -143,7 +143,7 @@ monitorLoop:
 		}
 
 		// invalid :(
-		network.backend.Filters.LogError("upnpMonitorPortForward", "port forwarding invalidated for local IP %s (adapter %s) external IP %s port %d\n", network.address.String(), network.iface.Name, network.ipExternal.String(), network.portExternal)
+		network.backend.LogError("upnpMonitorPortForward", "port forwarding invalidated for local IP %s (adapter %s) external IP %s port %d\n", network.address.String(), network.iface.Name, network.ipExternal.String(), network.portExternal)
 
 		network.portExternal = 0
 		network.ipExternal = net.IP{}
diff --git a/Network.go b/Network.go
index 5d8ff2b..3a83e05 100644
--- a/Network.go
+++ b/Network.go
@@ -116,8 +116,8 @@ func (network *Network) Listen() {
 				return
 			}
 
-			network.backend.Filters.LogError("Listen", "receiving UDP message: %v\n", err) // Only log for debug purposes.
-			time.Sleep(time.Millisecond * 50)                                              // In case of endless errors, prevent ddos of CPU.
+			network.backend.LogError("Listen", "receiving UDP message: %v\n", err) // Only log for debug purposes.
+			time.Sleep(time.Millisecond * 50)                                      // In case of endless errors, prevent ddos of CPU.
 			continue
 		}
 
@@ -136,7 +136,7 @@ func (nets *Networks) packetWorker() {
 	for packet := range nets.rawPacketsIncoming {
 		decoded, senderPublicKey, err := protocol.PacketDecrypt(packet.raw, packet.receiverPublicKey)
 		if err != nil {
-			//Filters.LogError("packetWorker", "decrypting packet from '%s': %s\n", packet.sender.String(), err.Error())  // Only log for debug purposes.
+			//LogError("packetWorker", "decrypting packet from '%s': %s\n", packet.sender.String(), err.Error())  // Only log for debug purposes.
 			continue
 		}
 
@@ -198,7 +198,7 @@ func (nets *Networks) packetWorker() {
 				isLast := response.IsLast()
 				sequenceInfo, valid, rtt := nets.Sequences.ValidateSequence(raw.SenderPublicKey, raw.Sequence, isLast, !isLast)
 				if !valid {
-					//Filters.LogError("packetWorker", "message with invalid sequence %d command %d from %s\n", raw.Sequence, raw.Command, raw.connection.Address.String()) // Only log for debug purposes.
+					//LogError("packetWorker", "message with invalid sequence %d command %d from %s\n", raw.Sequence, raw.Command, raw.connection.Address.String()) // Only log for debug purposes.
 					continue
 				} else if rtt > 0 {
 					connection.RoundTripTime = rtt
@@ -257,7 +257,7 @@ func (nets *Networks) packetWorker() {
 			// Validate sequence number which prevents unsolicited responses.
 			sequenceInfo, valid, rtt := nets.Sequences.ValidateSequence(raw.SenderPublicKey, raw.Sequence, true, false)
 			if !valid {
-				//Filters.LogError("packetWorker", "message with invalid sequence %d command %d from %s\n", raw.Sequence, raw.Command, raw.connection.Address.String()) // Only log for debug purposes.
+				//LogError("packetWorker", "message with invalid sequence %d command %d from %s\n", raw.Sequence, raw.Command, raw.connection.Address.String()) // Only log for debug purposes.
 				continue
 			} else if rtt > 0 {
 				connection.RoundTripTime = rtt
@@ -288,7 +288,7 @@ func (nets *Networks) packetWorker() {
 				isLast := msg.IsLast()
 				sequenceInfo, valid, rtt := nets.Sequences.ValidateSequenceBi(raw.SenderPublicKey, raw.Sequence, isLast)
 				if msg.Control != protocol.TransferControlRequestStart && !valid {
-					//Filters.LogError("packetWorker", "message with invalid sequence %d command %d from %s\n", raw.Sequence, raw.Command, raw.connection.Address.String()) // Only log for debug purposes.
+					//LogError("packetWorker", "message with invalid sequence %d command %d from %s\n", raw.Sequence, raw.Command, raw.connection.Address.String()) // Only log for debug purposes.
 					continue
 				} else if rtt > 0 {
 					connection.RoundTripTime = rtt
@@ -304,7 +304,7 @@ func (nets *Networks) packetWorker() {
 				isLast := msg.IsLast()
 				sequenceInfo, valid, rtt := nets.Sequences.ValidateSequenceBi(raw.SenderPublicKey, raw.Sequence, isLast)
 				if msg.Control != protocol.GetBlockControlRequestStart && !valid {
-					//Filters.LogError("packetWorker", "message with invalid sequence %d command %d from %s\n", raw.Sequence, raw.Command, raw.connection.Address.String()) // Only log for debug purposes.
+					//LogError("packetWorker", "message with invalid sequence %d command %d from %s\n", raw.Sequence, raw.Command, raw.connection.Address.String()) // Only log for debug purposes.
 					continue
 				} else if rtt > 0 {
 					connection.RoundTripTime = rtt
diff --git a/Peer ID.go b/Peer ID.go
index 3b2d935..be76c27 100644
--- a/Peer ID.go	
+++ b/Peer ID.go	
@@ -37,7 +37,7 @@ func (backend *Backend) initPeerID() {
 			return
 		}
 
-		backend.Filters.LogError("initPeerID", "private key in config is corrupted! Error: %s\n", err.Error())
+		backend.LogError("initPeerID", "private key in config is corrupted! Error: %s\n", err.Error())
 		os.Exit(ExitPrivateKeyCorrupt)
 	}
 
@@ -45,7 +45,7 @@ func (backend *Backend) initPeerID() {
 	var err error
 	backend.peerPrivateKey, backend.peerPublicKey, err = Secp256k1NewPrivateKey()
 	if err != nil {
-		backend.Filters.LogError("initPeerID", "generating public-private key pairs: %s\n", err.Error())
+		backend.LogError("initPeerID", "generating public-private key pairs: %s\n", err.Error())
 		os.Exit(ExitPrivateKeyCreate)
 	}
 	backend.nodeID = protocol.PublicKey2NodeID(backend.peerPublicKey)
diff --git a/Peernet.go b/Peernet.go
index 8f9c8d6..aba62d5 100644
--- a/Peernet.go
+++ b/Peernet.go
@@ -59,7 +59,7 @@ func Init(UserAgent string, ConfigFilename string, Filters *Filters) (backend *B
 	backend.initBlockchainCache()
 
 	if backend.SearchIndex, err = search.InitSearchIndexStore(backend.Config.SearchIndex); err != nil {
-		backend.Filters.LogError("Init", "search index '%s' init: %s", backend.Config.SearchIndex, err.Error())
+		backend.LogError("Init", "search index '%s' init: %s", backend.Config.SearchIndex, err.Error())
 	} else {
 		backend.userBlockchainUpdateSearchIndex()
 	}
diff --git a/Warehouse.go b/Warehouse.go
index 6fa9fca..f637c80 100644
--- a/Warehouse.go
+++ b/Warehouse.go
@@ -15,6 +15,6 @@ func (backend *Backend) initUserWarehouse() {
 	backend.UserWarehouse, err = warehouse.Init(backend.Config.WarehouseMain)
 
 	if err != nil {
-		backend.Filters.LogError("initUserWarehouse", "error: %s\n", err.Error())
+		backend.LogError("initUserWarehouse", "error: %s\n", err.Error())
 	}
 }
diff --git a/webapi/API.go b/webapi/API.go
index 9021380..f0b0abe 100644
--- a/webapi/API.go
+++ b/webapi/API.go
@@ -111,7 +111,7 @@ func Start(Backend *core.Backend, ListenAddresses []string, UseSSL bool, Certifi
 // startWebAPI starts a web-server with given parameters and logs the status. If may block forever and only returns if there is an error.
 // The certificate file and key are only used if SSL is enabled. The read and write timeout may be 0 for no timeout.
 func startWebAPI(Backend *core.Backend, WebListen string, UseSSL bool, CertificateFile, CertificateKey string, Handler http.Handler, Info string, ReadTimeout, WriteTimeout time.Duration) {
-	Backend.Filters.LogError("startWebAPI", "Start API at '%s'\n", WebListen)
+	Backend.LogError("startWebAPI", "Start API at '%s'\n", WebListen)
 
 	tlsConfig := &tls.Config{MinVersion: tls.VersionTLS12} // for security reasons disable TLS 1.0/1.1
 
@@ -127,12 +127,12 @@ func startWebAPI(Backend *core.Backend, WebListen string, UseSSL bool, Certifica
 	if UseSSL {
 		// HTTPS
 		if err := server.ListenAndServeTLS(CertificateFile, CertificateKey); err != nil {
-			Backend.Filters.LogError("startWebAPI", "Error listening on '%s': %v\n", WebListen, err)
+			Backend.LogError("startWebAPI", "Error listening on '%s': %v\n", WebListen, err)
 		}
 	} else {
 		// HTTP
 		if err := server.ListenAndServe(); err != nil {
-			Backend.Filters.LogError("startWebAPI", "Error listening on '%s': %v\n", WebListen, err)
+			Backend.LogError("startWebAPI", "Error listening on '%s': %v\n", WebListen, err)
 		}
 	}
 }
@@ -143,7 +143,7 @@ func EncodeJSON(Backend *core.Backend, w http.ResponseWriter, r *http.Request, d
 
 	err = json.NewEncoder(w).Encode(data)
 	if err != nil {
-		Backend.Filters.LogError("EncodeJSON", "Error writing data for route '%s': %v\n", r.URL.Path, err)
+		Backend.LogError("EncodeJSON", "Error writing data for route '%s': %v\n", r.URL.Path, err)
 	}
 
 	return err
diff --git a/webapi/Warehouse.go b/webapi/Warehouse.go
index 38ee878..0717611 100644
--- a/webapi/Warehouse.go
+++ b/webapi/Warehouse.go
@@ -29,7 +29,7 @@ func (api *WebapiInstance) apiWarehouseCreateFile(w http.ResponseWriter, r *http
 	hash, status, err := api.backend.UserWarehouse.CreateFile(r.Body, 0)
 
 	if err != nil {
-		api.backend.Filters.LogError("warehouse.CreateFile", "status %d error: %v", status, err)
+		api.backend.LogError("warehouse.CreateFile", "status %d error: %v", status, err)
 	}
 
 	EncodeJSON(api.backend, w, r, WarehouseResult{Status: status, Hash: hash})
@@ -54,7 +54,7 @@ func (api *WebapiInstance) apiWarehouseCreateFilePath(w http.ResponseWriter, r *
 	hash, status, err := api.backend.UserWarehouse.CreateFileFromPath(filePath)
 
 	if err != nil {
-		api.backend.Filters.LogError("warehouse.CreateFile", "status %d error: %v", status, err)
+		api.backend.LogError("warehouse.CreateFile", "status %d error: %v", status, err)
 	}
 
 	EncodeJSON(api.backend, w, r, WarehouseResult{Status: status, Hash: hash})
@@ -94,7 +94,7 @@ func (api *WebapiInstance) apiWarehouseReadFile(w http.ResponseWriter, r *http.R
 	}
 
 	if err != nil {
-		api.backend.Filters.LogError("warehouse.ReadFile", "status %d read %d error: %v", status, bytesRead, err)
+		api.backend.LogError("warehouse.ReadFile", "status %d read %d error: %v", status, bytesRead, err)
 	}
 }
 
@@ -115,7 +115,7 @@ func (api *WebapiInstance) apiWarehouseDeleteFile(w http.ResponseWriter, r *http
 	status, err := api.backend.UserWarehouse.DeleteFile(hash)
 
 	if err != nil {
-		api.backend.Filters.LogError("warehouse.DeleteFile", "status %d error: %v", status, err)
+		api.backend.LogError("warehouse.DeleteFile", "status %d error: %v", status, err)
 	}
 
 	EncodeJSON(api.backend, w, r, WarehouseResult{Status: status, Hash: hash})
@@ -144,7 +144,7 @@ func (api *WebapiInstance) apiWarehouseReadFilePath(w http.ResponseWriter, r *ht
 	status, bytesRead, err := api.backend.UserWarehouse.ReadFileToDisk(hash, int64(offset), int64(limit), targetFile)
 
 	if err != nil {
-		api.backend.Filters.LogError("warehouse.ReadFileToDisk", "status %d read %d error: %v", status, bytesRead, err)
+		api.backend.LogError("warehouse.ReadFileToDisk", "status %d read %d error: %v", status, bytesRead, err)
 	}
 
 	EncodeJSON(api.backend, w, r, WarehouseResult{Status: status, Hash: hash})