* there were several cases of GlobalLogger.error() << "Error: ..." which is redundant
* there was one instance of streaming to cerr instead of GlobalLogger.error
* remove trailing whitespace
     catch ( const std::exception &ex )
     {
         GlobalLogger.error() << "Error parsing command line options: " << ex.what() << endl;
-
-        if (true) // TODO: if GlobalLogger is not logging to console
-        {   // ensure that error about command line options shows on command line
-            cerr << "Error parsing command line options: " << ex.what() << endl;
-        }
-
         return false;
     }
 
 
 //-----------------------------------------------------------------------------
 
 /**
- * @brief This class represents the ""Ratio in (0,1] of hosts to use, picking 
+ * @brief This class represents the ""Ratio in (0,1] of hosts to use, picking
  * them at random from host list" configuration option.
  */
 class RatioRandomHostsOption : public ConfigurationOption
 
         size_t resolved_ip_count = answers_list.size();
         if ( resolved_ip_count < 1 )
         {
-            GlobalLogger.error() << "Error: IP host " << HostDnsAddress << " could not be resolved." << endl;
+            GlobalLogger.error() << "IP host " << HostDnsAddress << " could not be resolved." << endl;
             return false;
         }
 
     }
     catch ( const std::exception &ex )
     {
-        GlobalLogger.error() << "Error: host " << HostDnsAddress << " could not be resolved. "
+        GlobalLogger.error() << "Host " << HostDnsAddress << " could not be resolved. "
                 << ex.what() << endl;
         return false;
     }
     }
     catch ( const std::exception &ex )
     {
-        GlobalLogger.error() << "Error: name server " << name_server << " does not seem to be an IP address. ";
+        GlobalLogger.error() << "Name server " << name_server << " does not seem to be an IP address. ";
         throw;   // forward exception to next handler
     }
     boost::net::dns::resolve resolver;
 
     size_t data_received_in_bytes = static_cast<size_t>( is.gcount() );
     if ( data_received_in_bytes != PayloadSizeInBytes )
     {
-        GlobalLogger.error() << "Error: expecting " << PayloadSizeInBytes
+        GlobalLogger.error() << "Expecting " << PayloadSizeInBytes
                 << " bytes, but received " << is.gcount() << " bytes." << endl;
     }
 
 
     if ( ret == -1 )
     {
         I2n::Logger::GlobalLogger.error()
-            << "Error: could not bind pinger to interface " << Name << std::endl;
+            << "Could not bind pinger to interface " << Name << std::endl;
         return false;
     }
 
 
     }
     catch ( ... )
     {
-        GlobalLogger.error() << "Error: could not destroy network interface list."
+        GlobalLogger.error() << "Could not destroy network interface list."
                 << endl;                                                                       //lint !e1551
     }
 } //lint !e1579
 
 #include <boost/asio/ip/tcp_raw_protocol.hpp>
 #include <boost/system/system_error.hpp>
 
+#include <logfunc.hpp>
+
 #include "boost_assert_handler.h"
 #include "icmp/icmppinger.h"
 #include "tcp/tcppinger.h"
 using boost::asio::ip::icmp;
 using boost::asio::ip::tcp_raw_protocol;
 using boost::system::system_error;
+using I2n::Logger::GlobalLogger;
 
 //-----------------------------------------------------------------------------
 // PingerFactory
     {
         // Raw sockets are locked down by Unix operating systems to prevent
         // malware and security holes, thus it requires root access to use it.
-        cerr << "Error: pingcheck must run as root (" << ex.what() << ")" << endl;
+        GlobalLogger.error() << "Pingcheck must run as root (" << ex.what() << ")" << endl;
         exit( EXIT_FAILURE );
     }
 
 
     // determine if address resolution is required
     if ( !ips_up_to_date )
     {
-        ips_up_to_date = Ping->resolve_ping_address();    // try to resolve 
+        ips_up_to_date = Ping->resolve_ping_address();    // try to resolve
         if ( ips_up_to_date )
         {
             EverHadAnyIP = true;
 
             << IcmpPacket::return_code_to_string(return_code) << endl;
         icmp_packet.reset();    // --> (!icmp_packet) is true
            // --> icmp_pinger will not try to continue working with this packet
-
-        // TODO why good packets are reports as bad? The read() has problems!
     }
     else if ( !is.good() )
     {
 
     // try to read that amount of data
     if ( data_length < 0 )
     {
-        GlobalLogger.error() << "Error: invalid size for optional ICMP data: "
+        GlobalLogger.error() << "Invalid size for optional ICMP data: "
                              << data_length << endl;
         is.setstate( ios::failbit );
         return IcmpPacket::ReadReturnCode_INVALID_SIZE;
 
     // try to read that amount of data
     if ( data_length < 0 )
     {
-        GlobalLogger.error() << "Error: invalid size for optional ICMP data: "
+        GlobalLogger.error() << "Invalid size for optional ICMP data: "
                              << data_length << endl;
         is.setstate( ios::failbit );
         return IcmpPacket::ReadReturnCode_INVALID_SIZE;
 
     uint8_t header_version = header.get_version();
     if ( header_version != 4 )
     {
-        GlobalLogger.error() << "Error: invalid IP header version: " << static_cast<int>(header_version) << endl;
+        GlobalLogger.error() << "Invalid IP header version: " << static_cast<int>(header_version) << endl;
 
         is.setstate( ios::failbit );
         return is;
                                 static_cast<streamsize>( Ipv4HeaderSizeInBytes );
     if ( ( options_length < 0 ) || ( 40 < options_length ) )
     {
-        GlobalLogger.error() << "Error: invalid IP options length value:" << options_length << endl;
+        GlobalLogger.error() << "Invalid IP options length value:" << options_length << endl;
         is.setstate( ios::failbit );
     }
     else if ( ( 0 < options_length ) && ( options_length <= 40 ) )
 
 void init_logger();
 void set_log_output(const ConfigurationItem &);
 DelayMap calc_pinger_delays(const HostList &hosts);
-void init_pingers(const IoServiceItem, const ConfigurationItem&, 
+void init_pingers(const IoServiceItem, const ConfigurationItem&,
                   const LinkStatusItem&, PingSchedulerList*);
 void start_pingers(const PingSchedulerList&);
 void stop_pingers(const PingSchedulerList&);
 
 void init_logger()
 {
-    // set default: log at level NOTICE to syslog
-    const int default_log_level = I2n::Logger::LogLevel::Notice;
-
+    // set default: log at level NOTICE to syslog and stderr
+    //   to ensure that in case of faulty config, the error is noticed
     I2n::Logger::enable_syslog( I2n::Logger::Facility::User );
     I2n::Logger::enable_stderr_log( true );
-    I2n::Logger::set_log_level( default_log_level );
+    I2n::Logger::set_log_level( I2n::Logger::LogLevel::Notice );
 }
 
 void set_log_output(
  *
  * If there are many pingers with same interval, will get bursts of pings
  * and none in-between. This function calculates delays for large numbers
- * of hosts with same ping intervals, to distribute them as evenly as 
+ * of hosts with same ping intervals, to distribute them as evenly as
  * possible, right from the start (might diverge over time, anyway).
  *
  * Will not do much good for pingers with many different intervals, but
 // the one instance of signal_data_struct
 signal_data_struct signal_data;
 
+
+/// registered as signal handler; mainly sets signal_data.signaled_flag
 void signal_handler(int param)
 {
-    GlobalLogger.info() << "signal handler called with param " << param << endl;
+    if (param == SIGUSR1)
+        GlobalLogger.debug() << "signal handler called with SIGUSR1." << endl;
+    else if (param == SIGUSR2)
+        GlobalLogger.debug() << "signal handler called with SIGUSR2." << endl;
+    else if (param == SIGTERM)
+        GlobalLogger.debug() << "signal handler called with SIGTERM." << endl;
+    else if (param == SIGINT)
+        GlobalLogger.debug() << "signal handler called with SIGINT." << endl;
+    else
+        GlobalLogger.warning() << "signal handler called with unexpected signal " << param << endl;
     signal_data.signaled_flag = param;
 }
 
+
+/// called regularly from io_service; checks signal_data.signal_flag
 void signal_checker( const boost::system::error_code &error )
 {
     bool want_stop = false;
         }
         else
         {
-            GlobalLogger.error() << "not implemented yet! Stopping io_service" << endl;
+            GlobalLogger.error() << "Signal check timer handler received error code " << error
+                << "! Stopping io_service" << endl;
             want_stop = true;
         }
     }
         {
             int new_log_level = I2n::Logger::get_log_level()+1;
             I2n::Logger::set_log_level( new_log_level );
-            GlobalLogger.info() << "Increased log level to "
+            GlobalLogger.debug() << "Increased log level to "
                 << I2n::Logger::get_log_level_string();
         }
         else if ( signaled_flag == SIGUSR2 )
         {
             I2n::Logger::set_log_level( signal_data.config_log_level );
-            GlobalLogger.info() << "Reset log level to normal ("
+            GlobalLogger.debug() << "Reset log level to normal ("
                 << I2n::Logger::get_log_level_string() << ")";
         }
         else if ( ( signaled_flag == SIGTERM ) || ( signaled_flag == SIGINT ))
         {
-            GlobalLogger.info() << "Received signal SIGINT/SIGTERM --> will stop" << endl;
+            GlobalLogger.debug() << "Received signal SIGINT/SIGTERM --> will stop" << endl;
             want_stop = true;
         }
     }
 
 {
     if ( !NetInterface.bind() )
     {
-        GlobalLogger.error() << "Error: could not bind the socket with the local interface. "
+        GlobalLogger.error() << "Could not bind the socket with the local interface. "
                 << ::strerror( errno )  << endl;
     }
 
     ostream os( &request_buffer );
     if ( !tcp_segment->write( os ) )
     {
-        GlobalLogger.error() << "Error: fail writing ping data." << endl;
+        GlobalLogger.error() << "Fail writing ping data." << endl;
     }
 
     TimeSent = microsec_clock::universal_time();
         size_t bytes_sent = Socket.send_to( data, DestinationEndpoint );
         if ( bytes_sent != buffer_size( data ) )
         {
-            GlobalLogger.error() << "Error: fail sending ping data."
+            GlobalLogger.error() << "Fail sending ping data."
                     << "Amount of bytes sent differs from the buffer." << endl;
         }
     }
     catch ( const exception &ex )
     {
-        GlobalLogger.error() << "Error: fail sending ping data. " << ex.what() << endl;
+        GlobalLogger.error() << "Fail sending ping data. " << ex.what() << endl;
     }
 
     // Tell how long to wait for the reply
         istream is( &ReplyBuffer );
         if ( !is )
         {
-            GlobalLogger.error() << "Error: can't handle ReplyBuffer" << endl;
+            GlobalLogger.error() << "Can't handle ReplyBuffer" << endl;
             return;
         }
 
     }
     catch ( ... )
     {
-        GlobalLogger.notice() << "Warning: exception during ICMP parse. "
+        GlobalLogger.notice() << "Exception during ICMP parse. "
             << "Starting another receive till timeout." << endl;
         start_receive();
     }
 
 
     if ( !tcp_segment->read( is ) )
     {
-        GlobalLogger.error() << "Error: could not read TCP Segment." << endl;
+        GlobalLogger.error() << "Could not read TCP Segment." << endl;
     }
 
     return tcp_segment;