diff --git a/opm/parser/eclipse/Applications/opm-eclkwtest.cpp b/opm/parser/eclipse/Applications/opm-eclkwtest.cpp
index e0d8fff2f..28b196304 100644
--- a/opm/parser/eclipse/Applications/opm-eclkwtest.cpp
+++ b/opm/parser/eclipse/Applications/opm-eclkwtest.cpp
@@ -18,14 +18,14 @@
  */
 
 #include <iostream>
-#include <opm/parser/eclipse/Log/Logger.hpp>
+#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
 
 #include <opm/parser/eclipse/Parser/Parser.hpp>
 #include <opm/parser/eclipse/Deck/Deck.hpp>
 #include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
 
 
-static void printDeckDiagnostics(Opm::DeckConstPtr deck, Opm::LoggerConstPtr logger, bool printAllKeywords) {
+static void printDeckDiagnostics(Opm::DeckConstPtr deck, Opm::MessageCounterConstPtr logger, bool printAllKeywords) {
     int recognizedKeywords = 0;
     int unrecognizedKeywords = 0;
 
@@ -68,7 +68,7 @@ int main(int argc, char** argv) {
 
     Opm::ParserPtr parser(new Opm::Parser());
     std::string file = argv[1];
-    Opm::LoggerPtr logger(new Opm::Logger);
+    Opm::MessageCounterPtr logger(new Opm::MessageCounter);
     Opm::DeckConstPtr deck = parser->parseFile(file, logger);
     Opm::EclipseState state(deck);
 
diff --git a/opm/parser/eclipse/CMakeLists.txt b/opm/parser/eclipse/CMakeLists.txt
index 035ac1bbb..637a507de 100644
--- a/opm/parser/eclipse/CMakeLists.txt
+++ b/opm/parser/eclipse/CMakeLists.txt
@@ -15,7 +15,7 @@ endif()
 add_subdirectory( Applications )
 
 set( log_source
-Log/Logger.cpp 
+OpmLog/MessageCounter.cpp 
 OpmLog/OpmLog.cpp )
 
 set( rawdeck_source 
@@ -103,7 +103,7 @@ EclipseState/SimulationConfig/SimulationConfig.cpp
 EclipseState/SimulationConfig/ThresholdPressure.cpp)
 
 set( HEADER_FILES
-Log/Logger.hpp
+OpmLog/MessageCounter.hpp
 OpmLog/OpmLog.hpp
 #
 RawDeck/RawConsts.hpp 
diff --git a/opm/parser/eclipse/Deck/Section.cpp b/opm/parser/eclipse/Deck/Section.cpp
index 31b5fd3ef..c059e6a4f 100644
--- a/opm/parser/eclipse/Deck/Section.cpp
+++ b/opm/parser/eclipse/Deck/Section.cpp
@@ -24,7 +24,7 @@
 #include <set>
 #include <string>
 
-#include <opm/parser/eclipse/Log/Logger.hpp>
+#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
 
 #include <opm/parser/eclipse/Deck/Deck.hpp>
 #include <opm/parser/eclipse/Deck/Section.hpp>
@@ -100,7 +100,7 @@ namespace Opm {
     }
 
     bool Section::checkSectionTopology(DeckConstPtr deck,
-                                       LoggerPtr logger,
+                                       MessageCounterPtr logger,
                                        bool ensureKeywordSectionAffiliation)
     {
         if (deck->size() == 0) {
diff --git a/opm/parser/eclipse/Deck/Section.hpp b/opm/parser/eclipse/Deck/Section.hpp
index 09766cc09..0eddce861 100644
--- a/opm/parser/eclipse/Deck/Section.hpp
+++ b/opm/parser/eclipse/Deck/Section.hpp
@@ -20,7 +20,7 @@
 #ifndef SECTION_HPP
 #define SECTION_HPP
 
-#include <opm/parser/eclipse/Log/Logger.hpp>
+#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
 
 #include <opm/parser/eclipse/Deck/Deck.hpp>
 
@@ -56,7 +56,7 @@ namespace Opm {
         // returns whether the deck has all mandatory sections and if all sections are in
         // the right order
         static bool checkSectionTopology(DeckConstPtr deck,
-                                         LoggerPtr logger,
+                                         MessageCounterPtr logger,
                                          bool ensureKeywordSectionAffiliation = false);
 
     private:
diff --git a/opm/parser/eclipse/Deck/tests/DeckTests.cpp b/opm/parser/eclipse/Deck/tests/DeckTests.cpp
index c3c678145..18e0d50c7 100644
--- a/opm/parser/eclipse/Deck/tests/DeckTests.cpp
+++ b/opm/parser/eclipse/Deck/tests/DeckTests.cpp
@@ -24,7 +24,7 @@
 
 #include <boost/test/unit_test.hpp>
 
-#include <opm/parser/eclipse/Log/Logger.hpp>
+#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
 #include <opm/parser/eclipse/OpmLog/OpmLog.hpp>
 #include <opm/parser/eclipse/Deck/Deck.hpp>
 
@@ -123,13 +123,13 @@ BOOST_AUTO_TEST_CASE(size_twokeyword_return2) {
 
 
 BOOST_AUTO_TEST_CASE(DECKWARNING_EMPTYOK) {
-    Logger logger;
+    MessageCounter logger;
     BOOST_CHECK_EQUAL(0U, logger.size());
 }
 
 
 BOOST_AUTO_TEST_CASE(DECKAddWarning) {
-    Logger logger;
+    MessageCounter logger;
     logger.addNote("FILE", 100U, "NOTE");
     BOOST_CHECK_EQUAL(1U, logger.size());
 
diff --git a/opm/parser/eclipse/Deck/tests/SectionTests.cpp b/opm/parser/eclipse/Deck/tests/SectionTests.cpp
index 1aef2e855..8d8ebf77c 100644
--- a/opm/parser/eclipse/Deck/tests/SectionTests.cpp
+++ b/opm/parser/eclipse/Deck/tests/SectionTests.cpp
@@ -243,7 +243,7 @@ BOOST_AUTO_TEST_CASE(Section_ValidDecks) {
     deck->addKeyword(std::make_shared<DeckKeyword>("SCHEDULE"));
     deck->addKeyword(std::make_shared<DeckKeyword>("TEST5"));
 
-    LoggerPtr logger(new Logger());
+    MessageCounterPtr logger(new MessageCounter());
     BOOST_CHECK(Opm::Section::checkSectionTopology(deck, logger));
 
     // deck with all optional sections
@@ -295,7 +295,7 @@ BOOST_AUTO_TEST_CASE(Section_InvalidDecks) {
     deck->addKeyword(std::make_shared<DeckKeyword>("SCHEDULE"));
     deck->addKeyword(std::make_shared<DeckKeyword>("TEST5"));
 
-    LoggerPtr logger(new Logger());
+    MessageCounterPtr logger(new MessageCounter());
     BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, logger));
 
     // wrong section order
diff --git a/opm/parser/eclipse/EclipseState/EclipseState.cpp b/opm/parser/eclipse/EclipseState/EclipseState.cpp
index 3621b1f13..efcdc7b19 100644
--- a/opm/parser/eclipse/EclipseState/EclipseState.cpp
+++ b/opm/parser/eclipse/EclipseState/EclipseState.cpp
@@ -22,7 +22,7 @@
 #include <math.h>
 #include <boost/algorithm/string/join.hpp>
 
-#include <opm/parser/eclipse/Log/Logger.hpp>
+#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
 #include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
@@ -121,7 +121,7 @@ namespace Opm {
     }
 
 
-    EclipseState::EclipseState(DeckConstPtr deck, LoggerPtr logger)
+    EclipseState::EclipseState(DeckConstPtr deck, MessageCounterPtr logger)
         : m_defaultRegion("FLUXNUM")
     {
         m_deckUnitSystem = deck->getActiveUnitSystem();
@@ -264,7 +264,7 @@ namespace Opm {
         return m_title;
     }
 
-    void EclipseState::initTables(DeckConstPtr deck, LoggerPtr logger) {
+    void EclipseState::initTables(DeckConstPtr deck, MessageCounterPtr logger) {
         initSimpleTables(deck, logger, "ENKRVD", m_enkrvdTables);
         initSimpleTables(deck, logger, "ENPTVD", m_enptvdTables);
         initSimpleTables(deck, logger, "IMKRVD", m_imkrvdTables);
@@ -307,7 +307,7 @@ namespace Opm {
         initFullTables(deck, logger, "PVTO", m_pvtoTables);
    }
 
-    void EclipseState::initSchedule(DeckConstPtr deck, LoggerPtr logger) {
+    void EclipseState::initSchedule(DeckConstPtr deck, MessageCounterPtr logger) {
         schedule = ScheduleConstPtr( new Schedule(getEclipseGrid() , deck, logger) );
     }
 
@@ -315,7 +315,7 @@ namespace Opm {
         m_simulationConfig = std::make_shared<const SimulationConfig>(deck , m_intGridProperties);
     }
 
-    void EclipseState::initTransMult(LoggerPtr /*logger*/) {
+    void EclipseState::initTransMult(MessageCounterPtr /*logger*/) {
         EclipseGridConstPtr grid = getEclipseGrid();
         m_transMult = std::make_shared<TransMult>( grid->getNX() , grid->getNY() , grid->getNZ());
 
@@ -335,7 +335,7 @@ namespace Opm {
             m_transMult->applyMULT(m_doubleGridProperties->getKeyword("MULTZ-"), FaceDir::ZMinus);
     }
 
-    void EclipseState::initFaults(DeckConstPtr deck, LoggerPtr logger) {
+    void EclipseState::initFaults(DeckConstPtr deck, MessageCounterPtr logger) {
         EclipseGridConstPtr grid = getEclipseGrid();
         m_faults = std::make_shared<FaultCollection>();
         std::shared_ptr<Opm::GRIDSection> gridSection(new Opm::GRIDSection(deck) );
@@ -381,7 +381,7 @@ namespace Opm {
 
 
 
-    void EclipseState::setMULTFLT(std::shared_ptr<const Section> section, LoggerPtr /*logger*/) const {
+    void EclipseState::setMULTFLT(std::shared_ptr<const Section> section, MessageCounterPtr /*logger*/) const {
         for (size_t index=0; index < section->count("MULTFLT"); index++) {
             DeckKeywordConstPtr faultsKeyword = section->getKeyword("MULTFLT" , index);
             for (auto iter = faultsKeyword->begin(); iter != faultsKeyword->end(); ++iter) {
@@ -396,7 +396,7 @@ namespace Opm {
 
 
 
-    void EclipseState::initMULTREGT(DeckConstPtr deck, LoggerPtr /*logger*/) {
+    void EclipseState::initMULTREGT(DeckConstPtr deck, MessageCounterPtr /*logger*/) {
         EclipseGridConstPtr grid = getEclipseGrid();
 
         std::vector<Opm::DeckKeywordConstPtr> multregtKeywords;
@@ -409,7 +409,7 @@ namespace Opm {
 
 
 
-    void EclipseState::initEclipseGrid(DeckConstPtr deck, LoggerPtr logger) {
+    void EclipseState::initEclipseGrid(DeckConstPtr deck, MessageCounterPtr logger) {
         m_eclipseGrid = EclipseGridConstPtr( new EclipseGrid(deck, logger));
     }
 
@@ -461,7 +461,7 @@ namespace Opm {
     }
 
 
-    void EclipseState::initPhases(DeckConstPtr deck, LoggerPtr logger) {
+    void EclipseState::initPhases(DeckConstPtr deck, MessageCounterPtr logger) {
         if (deck->hasKeyword("OIL"))
             phases.insert(Phase::PhaseEnum::OIL);
 
@@ -480,7 +480,7 @@ namespace Opm {
          return (phases.count(phase) == 1);
     }
 
-    void EclipseState::initTitle(DeckConstPtr deck, LoggerPtr /*logger*/){
+    void EclipseState::initTitle(DeckConstPtr deck, MessageCounterPtr /*logger*/){
         if (deck->hasKeyword("TITLE")) {
             DeckKeywordConstPtr titleKeyword = deck->getKeyword("TITLE");
             DeckRecordConstPtr record = titleKeyword->getRecord(0);
@@ -490,7 +490,7 @@ namespace Opm {
         }
     }
 
-    void EclipseState::initRocktabTables(DeckConstPtr deck, LoggerPtr logger) {
+    void EclipseState::initRocktabTables(DeckConstPtr deck, MessageCounterPtr logger) {
         if (!deck->hasKeyword("ROCKTAB"))
             return; // ROCKTAB is not featured by the deck...
 
@@ -528,7 +528,7 @@ namespace Opm {
     }
 
     void EclipseState::initGasvisctTables(DeckConstPtr deck,
-                                          LoggerPtr logger,
+                                          MessageCounterPtr logger,
                                           const std::string& keywordName,
                                           std::vector<GasvisctTable>& tableVector) {
         if (!deck->hasKeyword(keywordName))
@@ -630,7 +630,7 @@ namespace Opm {
 
     void EclipseState::loadGridPropertyFromDeckKeyword(std::shared_ptr<const Box> inputBox,
                                                        DeckKeywordConstPtr deckKeyword,
-                                                       LoggerPtr logger,
+                                                       MessageCounterPtr logger,
                                                        int enabledTypes) {
         const std::string& keyword = deckKeyword->name();
         if (m_intGridProperties->supportsKeyword( keyword )) {
@@ -651,7 +651,7 @@ namespace Opm {
     }
 
 
-    void EclipseState::initProperties(DeckConstPtr deck, LoggerPtr logger) {
+    void EclipseState::initProperties(DeckConstPtr deck, MessageCounterPtr logger) {
         typedef GridProperties<int>::SupportedKeywordInfo SupportedIntKeywordInfo;
         std::shared_ptr<std::vector<SupportedIntKeywordInfo> > supportedIntKeywords(new std::vector<SupportedIntKeywordInfo>{
             SupportedIntKeywordInfo( "SATNUM" , 1, "1" ),
@@ -869,7 +869,7 @@ namespace Opm {
         return m_deckUnitSystem->getDimension(dimensionString)->getSIScaling();
     }
 
-    void EclipseState::processGridProperties(Opm::DeckConstPtr deck, LoggerPtr logger, int enabledTypes) {
+    void EclipseState::processGridProperties(Opm::DeckConstPtr deck, MessageCounterPtr logger, int enabledTypes) {
 
         if (Section::hasGRID(deck)) {
             std::shared_ptr<Opm::GRIDSection> gridSection(new Opm::GRIDSection(deck) );
@@ -899,7 +899,7 @@ namespace Opm {
     }
 
     void EclipseState::scanSection(std::shared_ptr<Opm::Section> section,
-                                   LoggerPtr logger,
+                                   MessageCounterPtr logger,
                                    int enabledTypes) {
         BoxManager boxManager(m_eclipseGrid->getNX( ) , m_eclipseGrid->getNY() , m_eclipseGrid->getNZ());
         for (auto iter = section->begin(); iter != section->end(); ++iter) {
@@ -947,7 +947,7 @@ namespace Opm {
 
 
 
-    void EclipseState::handleBOXKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr /*logger*/, BoxManager& boxManager) {
+    void EclipseState::handleBOXKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr /*logger*/, BoxManager& boxManager) {
         DeckRecordConstPtr record = deckKeyword->getRecord(0);
         int I1 = record->getItem("I1")->getInt(0) - 1;
         int I2 = record->getItem("I2")->getInt(0) - 1;
@@ -965,7 +965,7 @@ namespace Opm {
     }
 
 
-    void EclipseState::handleEQUALREGKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr , int enabledTypes) {
+    void EclipseState::handleEQUALREGKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr , int enabledTypes) {
         EclipseGridConstPtr grid = getEclipseGrid();
         for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
             DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
@@ -1008,7 +1008,7 @@ namespace Opm {
     }
 
 
-    void EclipseState::handleADDREGKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr , int enabledTypes) {
+    void EclipseState::handleADDREGKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr , int enabledTypes) {
         EclipseGridConstPtr grid = getEclipseGrid();
         for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
             DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
@@ -1053,7 +1053,7 @@ namespace Opm {
 
 
 
-    void EclipseState::handleMULTIREGKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr , int enabledTypes) {
+    void EclipseState::handleMULTIREGKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr , int enabledTypes) {
         EclipseGridConstPtr grid = getEclipseGrid();
         for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
             DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
@@ -1094,7 +1094,7 @@ namespace Opm {
     }
 
 
-    void EclipseState::handleCOPYREGKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr , int enabledTypes) {
+    void EclipseState::handleCOPYREGKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr , int enabledTypes) {
         EclipseGridConstPtr grid = getEclipseGrid();
         for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
             DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
@@ -1138,7 +1138,7 @@ namespace Opm {
 
 
 
-    void EclipseState::handleMULTIPLYKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr logger, BoxManager& boxManager, int enabledTypes) {
+    void EclipseState::handleMULTIPLYKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr logger, BoxManager& boxManager, int enabledTypes) {
         for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
             DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
             const std::string& field = record->getItem("field")->getString(0);
@@ -1170,7 +1170,7 @@ namespace Opm {
       some state dependent semantics regarding endpoint scaling arrays
       in the PROPS section. That is not supported.
     */
-    void EclipseState::handleADDKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr logger, BoxManager& boxManager, int enabledTypes) {
+    void EclipseState::handleADDKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr logger, BoxManager& boxManager, int enabledTypes) {
         for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
             DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
             const std::string& field = record->getItem("field")->getString(0);
@@ -1200,7 +1200,7 @@ namespace Opm {
     }
 
 
-    void EclipseState::handleEQUALSKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr logger, BoxManager& boxManager, int enabledTypes) {
+    void EclipseState::handleEQUALSKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr logger, BoxManager& boxManager, int enabledTypes) {
         for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
             DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
             const std::string& field = record->getItem("field")->getString(0);
@@ -1231,7 +1231,7 @@ namespace Opm {
 
 
 
-    void EclipseState::handleCOPYKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr logger, BoxManager& boxManager, int enabledTypes) {
+    void EclipseState::handleCOPYKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr logger, BoxManager& boxManager, int enabledTypes) {
         for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
             DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
             const std::string& srcField = record->getItem("src")->getString(0);
@@ -1271,7 +1271,7 @@ namespace Opm {
 
 
 
-    void EclipseState::setKeywordBox(DeckKeywordConstPtr deckKeyword, size_t recordIdx, LoggerPtr logger, BoxManager& boxManager) {
+    void EclipseState::setKeywordBox(DeckKeywordConstPtr deckKeyword, size_t recordIdx, MessageCounterPtr logger, BoxManager& boxManager) {
         auto deckRecord = deckKeyword->getRecord(recordIdx);
 
         DeckItemConstPtr I1Item = deckRecord->getItem("I1");
@@ -1314,7 +1314,7 @@ namespace Opm {
                                 "BOX modifiers on keywords must be either specified completely or not at all. Ignoring.");
     }
 
-    void EclipseState::complainAboutAmbiguousKeyword(DeckConstPtr deck, LoggerPtr logger, const std::string& keywordName) const {
+    void EclipseState::complainAboutAmbiguousKeyword(DeckConstPtr deck, MessageCounterPtr logger, const std::string& keywordName) const {
         logger->addError("", -1,
                             "The "+keywordName+" keyword must be unique in the deck. Ignoring all!");
         auto keywords = deck->getKeywordList(keywordName);
diff --git a/opm/parser/eclipse/EclipseState/EclipseState.hpp b/opm/parser/eclipse/EclipseState/EclipseState.hpp
index cd2163727..3620d3c70 100644
--- a/opm/parser/eclipse/EclipseState/EclipseState.hpp
+++ b/opm/parser/eclipse/EclipseState/EclipseState.hpp
@@ -21,7 +21,7 @@
 #define OPM_ECLIPSE_STATE_HPP
 
 #include <opm/parser/eclipse/Deck/Deck.hpp>
-#include <opm/parser/eclipse/Log/Logger.hpp>
+#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
 
 #include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
 #include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
@@ -72,7 +72,7 @@ namespace Opm {
             AllProperties = IntProperties | DoubleProperties
         };
 
-        EclipseState(DeckConstPtr deck, LoggerPtr logger = std::make_shared<Logger>(&std::cout));
+        EclipseState(DeckConstPtr deck, MessageCounterPtr logger = std::make_shared<MessageCounter>(&std::cout));
 
         ScheduleConstPtr getSchedule() const;
         SimulationConfigConstPtr getSimulationConfig() const;
@@ -91,7 +91,7 @@ namespace Opm {
 
         void loadGridPropertyFromDeckKeyword(std::shared_ptr<const Box> inputBox,
                                              DeckKeywordConstPtr deckKeyword,
-                                             LoggerPtr logger,
+                                             MessageCounterPtr logger,
                                              int enabledTypes = AllProperties);
 
         std::shared_ptr<const FaultCollection> getFaults() const;
@@ -130,20 +130,20 @@ namespace Opm {
         std::shared_ptr<const UnitSystem> getDeckUnitSystem()  const;
 
     private:
-        void initTables(DeckConstPtr deck, LoggerPtr logger);
-        void initSchedule(DeckConstPtr deck, LoggerPtr logger);
+        void initTables(DeckConstPtr deck, MessageCounterPtr logger);
+        void initSchedule(DeckConstPtr deck, MessageCounterPtr logger);
         void initSimulationConfig(DeckConstPtr deck);
-        void initEclipseGrid(DeckConstPtr deck, LoggerPtr logger);
+        void initEclipseGrid(DeckConstPtr deck, MessageCounterPtr logger);
         void initGridopts(DeckConstPtr deck);
-        void initPhases(DeckConstPtr deck, LoggerPtr logger);
-        void initTitle(DeckConstPtr deck, LoggerPtr logger);
-        void initProperties(DeckConstPtr deck, LoggerPtr logger);
-        void initTransMult(LoggerPtr logger);
-        void initFaults(DeckConstPtr deck, LoggerPtr logger);
+        void initPhases(DeckConstPtr deck, MessageCounterPtr logger);
+        void initTitle(DeckConstPtr deck, MessageCounterPtr logger);
+        void initProperties(DeckConstPtr deck, MessageCounterPtr logger);
+        void initTransMult(MessageCounterPtr logger);
+        void initFaults(DeckConstPtr deck, MessageCounterPtr logger);
 
         template <class TableType>
         void initSimpleTables(DeckConstPtr deck,
-                              LoggerPtr logger,
+                              MessageCounterPtr logger,
                               const std::string& keywordName,
                               std::vector<TableType>& tableVector) {
             if (!deck->hasKeyword(keywordName))
@@ -177,7 +177,7 @@ namespace Opm {
 
         template <class TableType>
         void initFullTables(DeckConstPtr deck,
-                            LoggerPtr logger,
+                            MessageCounterPtr logger,
                             const std::string& keywordName,
                             std::vector<TableType>& tableVector) {
             if (!deck->hasKeyword(keywordName))
@@ -197,37 +197,38 @@ namespace Opm {
             }
         }
 
-        void initRocktabTables(DeckConstPtr deck, LoggerPtr logger);
+        void initRocktabTables(DeckConstPtr deck, MessageCounterPtr logger);
         void initGasvisctTables(DeckConstPtr deck,
                                 LoggerPtr logger,
                                 const std::string& keywordName,
                                 std::vector<GasvisctTable>& tableVector);
+        void initRocktabTables(DeckConstPtr deck, MessageCounterPtr logger);
 
-        void setMULTFLT(std::shared_ptr<const Section> section, LoggerPtr logger) const;
-        void initMULTREGT(DeckConstPtr deck, LoggerPtr logger);
+        void setMULTFLT(std::shared_ptr<const Section> section, MessageCounterPtr logger) const;
+        void initMULTREGT(DeckConstPtr deck, MessageCounterPtr logger);
 
         double getSIScaling(const std::string &dimensionString) const;
 
-        void processGridProperties(Opm::DeckConstPtr deck, LoggerPtr logger, int enabledTypes);
-        void scanSection(std::shared_ptr<Opm::Section> section, LoggerPtr logger, int enabledTypes);
-        void handleADDKeyword(DeckKeywordConstPtr deckKeyword , LoggerPtr logger, BoxManager& boxManager, int enabledTypes);
-        void handleBOXKeyword(DeckKeywordConstPtr deckKeyword , LoggerPtr logger, BoxManager& boxManager);
-        void handleCOPYKeyword(DeckKeywordConstPtr deckKeyword , LoggerPtr logger, BoxManager& boxManager, int enabledTypes);
+        void processGridProperties(Opm::DeckConstPtr deck, MessageCounterPtr logger, int enabledTypes);
+        void scanSection(std::shared_ptr<Opm::Section> section, MessageCounterPtr logger, int enabledTypes);
+        void handleADDKeyword(DeckKeywordConstPtr deckKeyword , MessageCounterPtr logger, BoxManager& boxManager, int enabledTypes);
+        void handleBOXKeyword(DeckKeywordConstPtr deckKeyword , MessageCounterPtr logger, BoxManager& boxManager);
+        void handleCOPYKeyword(DeckKeywordConstPtr deckKeyword , MessageCounterPtr logger, BoxManager& boxManager, int enabledTypes);
         void handleENDBOXKeyword(BoxManager& boxManager);
-        void handleEQUALSKeyword(DeckKeywordConstPtr deckKeyword , LoggerPtr logger, BoxManager& boxManager, int enabledTypes);
-        void handleMULTIPLYKeyword(DeckKeywordConstPtr deckKeyword , LoggerPtr logger, BoxManager& boxManager, int enabledTypes);
+        void handleEQUALSKeyword(DeckKeywordConstPtr deckKeyword , MessageCounterPtr logger, BoxManager& boxManager, int enabledTypes);
+        void handleMULTIPLYKeyword(DeckKeywordConstPtr deckKeyword , MessageCounterPtr logger, BoxManager& boxManager, int enabledTypes);
 
-        void handleEQUALREGKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr logger, int enabledTypes);
-        void handleMULTIREGKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr logger, int enabledTypes);
-        void handleADDREGKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr logger, int enabledTypes);
-        void handleCOPYREGKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr logger, int enabledTypes);
+        void handleEQUALREGKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr logger, int enabledTypes);
+        void handleMULTIREGKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr logger, int enabledTypes);
+        void handleADDREGKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr logger, int enabledTypes);
+        void handleCOPYREGKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr logger, int enabledTypes);
 
-        void setKeywordBox(DeckKeywordConstPtr deckKeyword, size_t recordIdx, LoggerPtr logger, BoxManager& boxManager);
+        void setKeywordBox(DeckKeywordConstPtr deckKeyword, size_t recordIdx, MessageCounterPtr logger, BoxManager& boxManager);
 
         void copyIntKeyword(const std::string& srcField , const std::string& targetField , std::shared_ptr<const Box> inputBox);
         void copyDoubleKeyword(const std::string& srcField , const std::string& targetField , std::shared_ptr<const Box> inputBox);
 
-        void complainAboutAmbiguousKeyword(DeckConstPtr deck, LoggerPtr logger, const std::string& keywordName) const;
+        void complainAboutAmbiguousKeyword(DeckConstPtr deck, MessageCounterPtr logger, const std::string& keywordName) const;
 
         EclipseGridConstPtr m_eclipseGrid;
         ScheduleConstPtr schedule;
diff --git a/opm/parser/eclipse/EclipseState/Grid/EclipseGrid.cpp b/opm/parser/eclipse/EclipseState/Grid/EclipseGrid.cpp
index 2a0211bb3..7228e8115 100644
--- a/opm/parser/eclipse/EclipseState/Grid/EclipseGrid.cpp
+++ b/opm/parser/eclipse/EclipseState/Grid/EclipseGrid.cpp
@@ -96,7 +96,7 @@ namespace Opm {
         }
     } // anonymous namespace
 
-    EclipseGrid::EclipseGrid(std::shared_ptr<const Deck> deck, LoggerPtr logger)
+    EclipseGrid::EclipseGrid(std::shared_ptr<const Deck> deck, MessageCounterPtr logger)
         : m_minpvValue(0),
           m_minpvMode(MinpvMode::ModeEnum::Inactive),
           m_pinch("PINCH")
@@ -146,7 +146,7 @@ namespace Opm {
     }
 
 
-    void EclipseGrid::initGrid( const std::vector<int>& dims, DeckConstPtr deck, LoggerPtr logger) {
+    void EclipseGrid::initGrid( const std::vector<int>& dims, DeckConstPtr deck, MessageCounterPtr logger) {
         m_nx = static_cast<size_t>(dims[0]);
         m_ny = static_cast<size_t>(dims[1]);
         m_nz = static_cast<size_t>(dims[2]);
@@ -259,7 +259,7 @@ namespace Opm {
 
 
 
-    void EclipseGrid::initCornerPointGrid(const std::vector<int>& dims , DeckConstPtr deck, LoggerPtr logger) {
+    void EclipseGrid::initCornerPointGrid(const std::vector<int>& dims , DeckConstPtr deck, MessageCounterPtr logger) {
         assertCornerPointKeywords( dims , deck, logger);
         {
             DeckKeywordConstPtr ZCORNKeyWord = deck->getKeyword("ZCORN");
@@ -318,7 +318,7 @@ namespace Opm {
     }
 
 
-    void EclipseGrid::assertCornerPointKeywords( const std::vector<int>& dims , DeckConstPtr deck, LoggerPtr logger)
+    void EclipseGrid::assertCornerPointKeywords( const std::vector<int>& dims , DeckConstPtr deck, MessageCounterPtr logger)
     {
         const int nx = dims[0];
         const int ny = dims[1];
diff --git a/opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp b/opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp
index b17a0ed9a..9c8de02f1 100644
--- a/opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp
+++ b/opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp
@@ -21,7 +21,7 @@
 #ifndef ECLIPSE_GRID_HPP_
 #define ECLIPSE_GRID_HPP_
 
-#include <opm/parser/eclipse/Log/Logger.hpp>
+#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
 
 #include <opm/parser/eclipse/Deck/Deck.hpp>
 #include <opm/parser/eclipse/Deck/Section.hpp>
@@ -70,8 +70,7 @@ namespace Opm {
         explicit EclipseGrid(const ecl_grid_type * src_ptr);
         explicit EclipseGrid(size_t nx, size_t ny, size_t nz,
                              double dx = 1.0, double dy = 1.0, double dz = 1.0);
-        explicit EclipseGrid(std::shared_ptr<const Deck> deck, LoggerPtr logger = std::make_shared<Logger>());
-
+        explicit EclipseGrid(std::shared_ptr<const Deck> deck, MessageCounterPtr logger = std::make_shared<MessageCounter>());
         static bool hasCornerPointKeywords(std::shared_ptr<const Deck> deck);
         static bool hasCartesianKeywords(std::shared_ptr<const Deck> deck);
         size_t  getNumActive( ) const;
@@ -84,7 +83,7 @@ namespace Opm {
 
         MinpvMode::ModeEnum getMinpvMode() const;
         double getMinpvValue( ) const;
-        
+
         bool hasCellInfo() const;
 
         void assertGlobalIndex(size_t globalIndex) const;
@@ -119,12 +118,12 @@ namespace Opm {
         void assertCellInfo() const;
 
         void initCartesianGrid(const std::vector<int>& dims , DeckConstPtr deck);
-        void initCornerPointGrid(const std::vector<int>& dims , DeckConstPtr deck, LoggerPtr logger);
+        void initCornerPointGrid(const std::vector<int>& dims , DeckConstPtr deck, MessageCounterPtr logger);
         void initDTOPSGrid(const std::vector<int>& dims , DeckConstPtr deck);
         void initDVDEPTHZGrid(const std::vector<int>& dims , DeckConstPtr deck);
-        void initGrid(const std::vector<int>& dims, DeckConstPtr deck, LoggerPtr logger);
+        void initGrid(const std::vector<int>& dims, DeckConstPtr deck, MessageCounterPtr logger);
 
-        static void assertCornerPointKeywords(const std::vector<int>& dims, DeckConstPtr deck, LoggerPtr logger) ;
+        static void assertCornerPointKeywords(const std::vector<int>& dims, DeckConstPtr deck, MessageCounterPtr logger) ;
         static bool hasDVDEPTHZKeywords(DeckConstPtr deck);
         static bool hasDTOPSKeywords(DeckConstPtr deck);
         static void assertVectorSize(const std::vector<double>& vector , size_t expectedSize , const std::string& msg);
diff --git a/opm/parser/eclipse/EclipseState/Grid/tests/MULTREGTScannerTests.cpp b/opm/parser/eclipse/EclipseState/Grid/tests/MULTREGTScannerTests.cpp
index 2dea2a25c..97f084ea9 100644
--- a/opm/parser/eclipse/EclipseState/Grid/tests/MULTREGTScannerTests.cpp
+++ b/opm/parser/eclipse/EclipseState/Grid/tests/MULTREGTScannerTests.cpp
@@ -25,7 +25,7 @@
 #include <boost/test/unit_test.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
 
-#include <opm/parser/eclipse/Log/Logger.hpp>
+#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
 
 #include <opm/parser/eclipse/Parser/Parser.hpp>
 
@@ -235,6 +235,6 @@ static Opm::DeckPtr createCopyMULTNUMDeck() {
 
 BOOST_AUTO_TEST_CASE(MULTREGT_COPY_MULTNUM) {
     Opm::DeckPtr deck = createCopyMULTNUMDeck();
-    Opm::LoggerPtr logger(new Opm::Logger());
+    Opm::MessageCounterPtr logger(new Opm::MessageCounter());
     BOOST_CHECK_NO_THROW( Opm::EclipseState( deck, logger ));
 }
diff --git a/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp b/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp
index abb2b2c74..5ba451ce3 100644
--- a/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp
+++ b/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp
@@ -35,13 +35,13 @@
 
 namespace Opm {
 
-    Schedule::Schedule(std::shared_ptr<const EclipseGrid> grid , DeckConstPtr deck, LoggerPtr logger)
+    Schedule::Schedule(std::shared_ptr<const EclipseGrid> grid , DeckConstPtr deck, MessageCounterPtr logger)
         : m_grid(grid)
     {
         initFromDeck(deck, logger);
     }
 
-    void Schedule::initFromDeck(DeckConstPtr deck, LoggerPtr logger) {
+    void Schedule::initFromDeck(DeckConstPtr deck, MessageCounterPtr logger) {
         createTimeMap(deck, logger);
         addGroup( "FIELD", 0 );
         initRootGroupTreeNode(getTimeMap());
@@ -52,7 +52,7 @@ namespace Opm {
         m_rootGroupTree.reset(new DynamicState<GroupTreePtr>(timeMap, GroupTreePtr(new GroupTree())));
     }
 
-    void Schedule::createTimeMap(DeckConstPtr deck, LoggerPtr /*logger*/) {
+    void Schedule::createTimeMap(DeckConstPtr deck, MessageCounterPtr /*logger*/) {
         boost::posix_time::ptime startTime(defaultStartDate);
         if (deck->hasKeyword("START")) {
             DeckKeywordConstPtr startKeyword = deck->getKeyword("START");
@@ -62,7 +62,7 @@ namespace Opm {
         m_timeMap.reset(new TimeMap(startTime));
     }
 
-    void Schedule::iterateScheduleSection(DeckConstPtr deck, LoggerPtr logger) {
+    void Schedule::iterateScheduleSection(DeckConstPtr deck, MessageCounterPtr logger) {
         size_t currentStep = 0;
 
         std::vector<std::pair<DeckKeywordConstPtr , size_t> > rftProperties;
@@ -140,11 +140,11 @@ namespace Opm {
         checkUnhandledKeywords(deck);
     }
 
-    void Schedule::handleDATES(DeckKeywordConstPtr keyword, LoggerPtr /*logger*/) {
+    void Schedule::handleDATES(DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/) {
         m_timeMap->addFromDATESKeyword(keyword);
     }
 
-    void Schedule::handleTSTEP(DeckKeywordConstPtr keyword, LoggerPtr /*logger*/) {
+    void Schedule::handleTSTEP(DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/) {
         m_timeMap->addFromTSTEPKeyword(keyword);
     }
 
@@ -157,7 +157,7 @@ namespace Opm {
         return treeUpdated;
     }
 
-    void Schedule::handleWELSPECS(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep) {
+    void Schedule::handleWELSPECS(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep) {
         bool needNewTree = false;
         GroupTreePtr newTree = m_rootGroupTree->get(currentStep)->deepCopy();
 
@@ -186,7 +186,7 @@ namespace Opm {
         }
     }
 
-    void Schedule::checkWELSPECSConsistency(WellConstPtr well, DeckKeywordConstPtr keyword, size_t recordIdx, LoggerPtr logger) const {
+    void Schedule::checkWELSPECSConsistency(WellConstPtr well, DeckKeywordConstPtr keyword, size_t recordIdx, MessageCounterPtr logger) const {
         DeckRecordConstPtr record = keyword->getRecord(recordIdx);
         if (well->getHeadI() != record->getItem("HEAD_I")->getInt(0) - 1) {
             std::string msg =
@@ -206,7 +206,7 @@ namespace Opm {
         }
     }
 
-    void Schedule::handleWCONProducer(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep, bool isPredictionMode) {
+    void Schedule::handleWCONProducer(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep, bool isPredictionMode) {
         for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
             DeckRecordConstPtr record = keyword->getRecord(recordNr);
 
@@ -260,15 +260,15 @@ namespace Opm {
         }
     }
 
-    void Schedule::handleWCONHIST(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep) {
+    void Schedule::handleWCONHIST(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep) {
         handleWCONProducer(keyword, logger, currentStep, false);
     }
 
-    void Schedule::handleWCONPROD(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep) {
+    void Schedule::handleWCONPROD(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep) {
         handleWCONProducer(keyword, logger, currentStep, true);
     }
 
-    void Schedule::handleWCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, LoggerPtr /*logger*/, size_t currentStep) {
+    void Schedule::handleWCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/, size_t currentStep) {
         for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
             DeckRecordConstPtr record = keyword->getRecord(recordNr);
             const std::string& wellNamePattern = record->getItem("WELL")->getTrimmedString(0);
@@ -337,7 +337,7 @@ namespace Opm {
     }
 
 
-    void Schedule::handleWPOLYMER(DeckKeywordConstPtr keyword, LoggerPtr /*logger*/, size_t currentStep) {
+    void Schedule::handleWPOLYMER(DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/, size_t currentStep) {
         for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
             DeckRecordConstPtr record = keyword->getRecord(recordNr);
             const std::string& wellNamePattern = record->getItem("WELL")->getTrimmedString(0);
@@ -366,7 +366,7 @@ namespace Opm {
         }
     }
 
-    void Schedule::handleWCONINJH(DeckConstPtr deck, DeckKeywordConstPtr keyword, LoggerPtr /*logger*/, size_t currentStep) {
+    void Schedule::handleWCONINJH(DeckConstPtr deck, DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/, size_t currentStep) {
         for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
             DeckRecordConstPtr record = keyword->getRecord(recordNr);
             const std::string& wellName = record->getItem("WELL")->getTrimmedString(0);
@@ -408,7 +408,7 @@ namespace Opm {
         return data;
     }
 
-    void Schedule::handleWELOPEN(DeckKeywordConstPtr keyword, LoggerPtr /*logger*/, size_t currentStep, bool hascomplump) {
+    void Schedule::handleWELOPEN(DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/, size_t currentStep , bool hascomplump) {
         for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
             DeckRecordConstPtr record = keyword->getRecord(recordNr);
 
@@ -503,7 +503,7 @@ namespace Opm {
     }
 
 
-    void Schedule::handleGCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, LoggerPtr /*logger*/, size_t currentStep) {
+    void Schedule::handleGCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/, size_t currentStep) {
         for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
             DeckRecordConstPtr record = keyword->getRecord(recordNr);
             const std::string& groupName = record->getItem("GROUP")->getTrimmedString(0);
@@ -535,7 +535,7 @@ namespace Opm {
     }
 
 
-    void Schedule::handleGCONPROD(DeckKeywordConstPtr keyword, LoggerPtr /*logger*/, size_t currentStep) {
+    void Schedule::handleGCONPROD(DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/, size_t currentStep) {
         for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
             DeckRecordConstPtr record = keyword->getRecord(recordNr);
             const std::string& groupName = record->getItem("GROUP")->getTrimmedString(0);
@@ -557,7 +557,7 @@ namespace Opm {
         }
     }
 
-    void Schedule::handleCOMPDAT(DeckKeywordConstPtr keyword, LoggerPtr /*logger*/, size_t currentStep) {
+    void Schedule::handleCOMPDAT(DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/, size_t currentStep) {
         std::map<std::string , std::vector< CompletionPtr> > completionMapList = Completion::completionsFromCOMPDATKeyword( keyword );
         std::map<std::string , std::vector< CompletionPtr> >::iterator iter;
 
@@ -568,7 +568,7 @@ namespace Opm {
         }
     }
 
-    void Schedule::handleWGRUPCON(DeckKeywordConstPtr keyword, LoggerPtr /*logger*/, size_t currentStep) {
+    void Schedule::handleWGRUPCON(DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/, size_t currentStep) {
         for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
             DeckRecordConstPtr record = keyword->getRecord(recordNr);
             const std::string& wellName = record->getItem("WELL")->getTrimmedString(0);
@@ -589,7 +589,7 @@ namespace Opm {
         }
     }
 
-    void Schedule::handleGRUPTREE(DeckKeywordConstPtr keyword, LoggerPtr /*logger*/, size_t currentStep) {
+    void Schedule::handleGRUPTREE(DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/, size_t currentStep) {
         GroupTreePtr currentTree = m_rootGroupTree->get(currentStep);
         GroupTreePtr newTree = currentTree->deepCopy();
         for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
diff --git a/opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp b/opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp
index 58c1fdb73..526b7567d 100644
--- a/opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp
+++ b/opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp
@@ -19,7 +19,7 @@
 #ifndef SCHEDULE_HPP
 #define SCHEDULE_HPP
 
-#include <opm/parser/eclipse/Log/Logger.hpp>
+#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
 
 #include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
@@ -42,8 +42,7 @@ namespace Opm
 
     class Schedule {
     public:
-        Schedule(std::shared_ptr<const EclipseGrid> grid , DeckConstPtr deck, LoggerPtr logger=std::make_shared<Logger>());
-
+        Schedule(std::shared_ptr<const EclipseGrid> grid , DeckConstPtr deck, MessageCounterPtr logger=std::make_shared<MessageCounter>());
         boost::posix_time::ptime getStartTime() const
         { return m_timeMap->getStartTime(/*timeStepIdx=*/0); }
         TimeMapConstPtr getTimeMap() const;
@@ -71,29 +70,29 @@ namespace Opm
         std::shared_ptr<DynamicState<GroupTreePtr> > m_rootGroupTree;
 
         void addWellToGroup( GroupPtr newGroup , WellPtr well , size_t timeStep);
-        void initFromDeck(DeckConstPtr deck, LoggerPtr logger);
-        void createTimeMap(DeckConstPtr deck, LoggerPtr logger);
+        void initFromDeck(DeckConstPtr deck, MessageCounterPtr logger);
+        void createTimeMap(DeckConstPtr deck, MessageCounterPtr logger);
         void initRootGroupTreeNode(TimeMapConstPtr timeMap);
-        void iterateScheduleSection(DeckConstPtr deck, LoggerPtr logger);
+        void iterateScheduleSection(DeckConstPtr deck, MessageCounterPtr logger);
         bool handleGroupFromWELSPECS(const std::string& groupName, GroupTreePtr newTree) const;
         void addGroup(const std::string& groupName , size_t timeStep);
         void addWell(const std::string& wellName, DeckRecordConstPtr record, size_t timeStep);
-        void checkWELSPECSConsistency(WellConstPtr well, DeckKeywordConstPtr keyword, size_t recordIdx, LoggerPtr logger) const;
-        void handleWELSPECS(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
-        void handleWCONProducer(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep, bool isPredictionMode);
-        void handleWCONHIST(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
-        void handleWCONPROD(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
-        void handleWGRUPCON(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
-        void handleCOMPDAT(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
-        void handleWCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
-        void handleWPOLYMER(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
-        void handleWCONINJH(DeckConstPtr deck, DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
-        void handleWELOPEN(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep, bool hascomplump);
-        void handleGCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
-        void handleGCONPROD(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
-        void handleDATES(DeckKeywordConstPtr keyword, LoggerPtr logger);
-        void handleTSTEP(DeckKeywordConstPtr keyword, LoggerPtr logger);
-        void handleGRUPTREE(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
+        void checkWELSPECSConsistency(WellConstPtr well, DeckKeywordConstPtr keyword, size_t recordIdx, MessageCounterPtr logger) const;
+        void handleWELSPECS(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
+        void handleWCONProducer(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep, bool isPredictionMode);
+        void handleWCONHIST(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
+        void handleWCONPROD(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
+        void handleWGRUPCON(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
+        void handleCOMPDAT(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
+        void handleWCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
+        void handleWPOLYMER(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
+        void handleWCONINJH(DeckConstPtr deck, DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
+        void handleWELOPEN(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
+        void handleGCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
+        void handleGCONPROD(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
+        void handleDATES(DeckKeywordConstPtr keyword, MessageCounterPtr logger);
+        void handleTSTEP(DeckKeywordConstPtr keyword, MessageCounterPtr logger);
+        void handleGRUPTREE(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
         void handleWRFT(DeckKeywordConstPtr keyword, size_t currentStep);
         void handleWRFTPLT(DeckKeywordConstPtr keyword, size_t currentStep);
 
diff --git a/opm/parser/eclipse/EclipseState/checkDeck.cpp b/opm/parser/eclipse/EclipseState/checkDeck.cpp
index 3347dfb16..fd8d79a23 100644
--- a/opm/parser/eclipse/EclipseState/checkDeck.cpp
+++ b/opm/parser/eclipse/EclipseState/checkDeck.cpp
@@ -21,7 +21,7 @@
 #include <opm/parser/eclipse/Deck/Section.hpp>
 
 namespace Opm {
-bool checkDeck(DeckConstPtr deck, LoggerPtr logger, size_t enabledChecks) {
+bool checkDeck(DeckConstPtr deck, MessageCounterPtr logger, size_t enabledChecks) {
     bool deckValid = true;
 
     // make sure that the deck does not contain unknown keywords
diff --git a/opm/parser/eclipse/EclipseState/checkDeck.hpp b/opm/parser/eclipse/EclipseState/checkDeck.hpp
index 98758c309..565c86dc5 100644
--- a/opm/parser/eclipse/EclipseState/checkDeck.hpp
+++ b/opm/parser/eclipse/EclipseState/checkDeck.hpp
@@ -20,7 +20,7 @@
 #ifndef OPM_CHECK_DECK_HPP
 #define OPM_CHECK_DECK_HPP
 
-#include <opm/parser/eclipse/Log/Logger.hpp>
+#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
 #include <opm/parser/eclipse/Deck/Deck.hpp>
 
 namespace Opm {
@@ -37,7 +37,7 @@ enum DeckChecks {
 
 // some semantical correctness checks of the deck. this method adds a warning to
 // the deck object if any issue is found ...
-bool checkDeck(DeckConstPtr deck, LoggerPtr logger, size_t enabledChecks = AllChecks);
+bool checkDeck(DeckConstPtr deck, MessageCounterPtr logger, size_t enabledChecks = AllChecks);
 }
 
 #endif
diff --git a/opm/parser/eclipse/EclipseState/tests/EclipseStateTests.cpp b/opm/parser/eclipse/EclipseState/tests/EclipseStateTests.cpp
index ef4e37d9e..d76f10b58 100644
--- a/opm/parser/eclipse/EclipseState/tests/EclipseStateTests.cpp
+++ b/opm/parser/eclipse/EclipseState/tests/EclipseStateTests.cpp
@@ -86,7 +86,7 @@ static DeckPtr createDeckTOP() {
 
 BOOST_AUTO_TEST_CASE(GetPOROTOPBased) {
     DeckPtr deck = createDeckTOP();
-    LoggerPtr logger(new Logger());
+    MessageCounterPtr logger(new MessageCounter());
     EclipseState state(deck, logger);
 
     std::shared_ptr<GridProperty<double> > poro = state.getDoubleGridProperty( "PORO" );
@@ -252,7 +252,7 @@ BOOST_AUTO_TEST_CASE(IntProperties) {
 
 BOOST_AUTO_TEST_CASE(PropertiesNotSupportedThrows) {
     DeckPtr deck = createDeck();
-    LoggerPtr logger(new Logger());
+    MessageCounterPtr logger(new MessageCounter());
     EclipseState state(deck);
     DeckKeywordConstPtr swat = deck->getKeyword("SWAT");
     BOOST_CHECK_EQUAL( false , state.supportsGridProperty("SWAT"));
diff --git a/opm/parser/eclipse/IntegrationTests/BoxTest.cpp b/opm/parser/eclipse/IntegrationTests/BoxTest.cpp
index 6e511e099..19f8e0f0d 100644
--- a/opm/parser/eclipse/IntegrationTests/BoxTest.cpp
+++ b/opm/parser/eclipse/IntegrationTests/BoxTest.cpp
@@ -29,9 +29,9 @@
 using namespace Opm;
 
 // forward declaration to avoid a pedantic compiler warning
-EclipseState makeState(const std::string& fileName, LoggerPtr logger);
+EclipseState makeState(const std::string& fileName, MessageCounterPtr logger);
 
-EclipseState makeState(const std::string& fileName, LoggerPtr logger) {
+EclipseState makeState(const std::string& fileName, MessageCounterPtr logger) {
     ParserPtr parser(new Parser( ));
     boost::filesystem::path boxFile(fileName);
     DeckPtr deck =  parser->parseFile(boxFile.string());
@@ -42,7 +42,7 @@ EclipseState makeState(const std::string& fileName, LoggerPtr logger) {
 
 
 BOOST_AUTO_TEST_CASE( PERMX ) {
-    LoggerPtr logger(new Logger());
+    MessageCounterPtr logger(new MessageCounter());
     EclipseState state = makeState("testdata/integration_tests/BOX/BOXTEST1" , logger);
     std::shared_ptr<GridProperty<double> > permx = state.getDoubleGridProperty("PERMX");
     std::shared_ptr<GridProperty<double> > permy = state.getDoubleGridProperty("PERMY");
@@ -65,7 +65,7 @@ BOOST_AUTO_TEST_CASE( PERMX ) {
 
 
 BOOST_AUTO_TEST_CASE( PARSE_BOX_OK ) {
-    LoggerPtr logger(new Logger());
+    MessageCounterPtr logger(new MessageCounter());
     EclipseState state = makeState("testdata/integration_tests/BOX/BOXTEST1", logger);
     std::shared_ptr<GridProperty<int> > satnum = state.getIntGridProperty("SATNUM");
     {
@@ -90,7 +90,7 @@ BOOST_AUTO_TEST_CASE( PARSE_BOX_OK ) {
 
 
 BOOST_AUTO_TEST_CASE( PARSE_MULTIPLY_COPY ) {
-    LoggerPtr logger(new Logger());
+    MessageCounterPtr logger(new MessageCounter());
     EclipseState state = makeState("testdata/integration_tests/BOX/BOXTEST1", logger);
     std::shared_ptr<GridProperty<int> > satnum = state.getIntGridProperty("SATNUM");
     std::shared_ptr<GridProperty<int> > fipnum = state.getIntGridProperty("FIPNUM");
@@ -114,21 +114,21 @@ BOOST_AUTO_TEST_CASE( PARSE_MULTIPLY_COPY ) {
 
 
 BOOST_AUTO_TEST_CASE( INCOMPLETE_KEYWORD_BOX) {
-    LoggerPtr logger(new Logger());
+    MessageCounterPtr logger(new MessageCounter());
     makeState("testdata/integration_tests/BOX/BOXTEST2", logger);
     BOOST_CHECK(logger->numErrors() > 1);
 }
 
 
 BOOST_AUTO_TEST_CASE( KEYWORD_BOX_TOO_SMALL) {
-    LoggerPtr logger(new Logger());
+    MessageCounterPtr logger(new MessageCounter());
     BOOST_CHECK_THROW( makeState("testdata/integration_tests/BOX/BOXTEST3", logger) , std::invalid_argument);
 }
 
 
 
 BOOST_AUTO_TEST_CASE( EQUAL ) {
-    LoggerPtr logger(new Logger());
+    MessageCounterPtr logger(new MessageCounter());
     EclipseState state = makeState("testdata/integration_tests/BOX/BOXTEST1", logger);
     std::shared_ptr<GridProperty<int> > pvtnum = state.getIntGridProperty("PVTNUM");
     std::shared_ptr<GridProperty<int> > eqlnum = state.getIntGridProperty("EQLNUM");
diff --git a/opm/parser/eclipse/IntegrationTests/CheckDeckValidity.cpp b/opm/parser/eclipse/IntegrationTests/CheckDeckValidity.cpp
index 4daaf502c..de4e79fb3 100644
--- a/opm/parser/eclipse/IntegrationTests/CheckDeckValidity.cpp
+++ b/opm/parser/eclipse/IntegrationTests/CheckDeckValidity.cpp
@@ -50,7 +50,7 @@ BOOST_AUTO_TEST_CASE( KeywordInCorrectSection ) {
             "SCHEDULE\n";
 
         auto deck = parser->parseString(correctDeckString);
-        Opm::LoggerPtr logger(new Opm::Logger());
+        Opm::MessageCounterPtr logger(new Opm::MessageCounter());
         BOOST_CHECK(Opm::checkDeck(deck, logger));
     }
 
@@ -64,7 +64,7 @@ BOOST_AUTO_TEST_CASE( KeywordInCorrectSection ) {
             "SCHEDULE\n";
 
         auto deck = parser->parseString(correctDeckString);
-        Opm::LoggerPtr logger(new Opm::Logger());
+        Opm::MessageCounterPtr logger(new Opm::MessageCounter());
         BOOST_CHECK(!Opm::checkDeck(deck, logger));
         BOOST_CHECK(Opm::checkDeck(deck, logger, ~Opm::SectionTopology));
     }
@@ -91,7 +91,7 @@ BOOST_AUTO_TEST_CASE( KeywordInCorrectSection ) {
             "SCHEDULE\n";
 
         auto deck = parser->parseString(incorrectDeckString);
-        Opm::LoggerPtr logger(new Opm::Logger());
+        Opm::MessageCounterPtr logger(new Opm::MessageCounter());
         BOOST_CHECK(!Opm::checkDeck(deck, logger));
 
         // this is supposed to succeed as we don't ensure that all keywords are in the
diff --git a/opm/parser/eclipse/Log/Logger.cpp b/opm/parser/eclipse/OpmLog/MessageCounter.cpp
similarity index 76%
rename from opm/parser/eclipse/Log/Logger.cpp
rename to opm/parser/eclipse/OpmLog/MessageCounter.cpp
index a9b9d9cc8..4aa03612d 100644
--- a/opm/parser/eclipse/Log/Logger.cpp
+++ b/opm/parser/eclipse/OpmLog/MessageCounter.cpp
@@ -21,12 +21,12 @@
 #include <cassert>
 
 #include <opm/parser/eclipse/OpmLog/OpmLog.hpp>
-#include <opm/parser/eclipse/Log/Logger.hpp>
+#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
 
 
 
 namespace Opm {
-Logger::Logger() {
+MessageCounter::MessageCounter() {
     m_numErrors = 0;
     m_numWarnings = 0;
     m_numNotes = 0;
@@ -34,7 +34,7 @@ Logger::Logger() {
     setOutStream(NULL);
 }
 
-Logger::Logger(std::ostream* os) {
+MessageCounter::MessageCounter(std::ostream* os) {
     m_numErrors = 0;
     m_numWarnings = 0;
     m_numNotes = 0;
@@ -42,27 +42,27 @@ Logger::Logger(std::ostream* os) {
     setOutStream(os);
 }
 
-void Logger::setOutStream(std::ostream* os) {
+void MessageCounter::setOutStream(std::ostream* os) {
     m_outStream = os;
 }
 
-size_t Logger::size() const {
+size_t MessageCounter::size() const {
     return m_messages.size();
 }
 
-size_t Logger::numErrors() const {
+size_t MessageCounter::numErrors() const {
     return m_numErrors;
 }
 
-size_t Logger::numWarnings() const {
+size_t MessageCounter::numWarnings() const {
     return m_numWarnings;
 }
 
-size_t Logger::numNotes() const {
+size_t MessageCounter::numNotes() const {
     return m_numNotes;
 }
 
-void Logger::addMessage(const std::string& fileName,
+void MessageCounter::addMessage(const std::string& fileName,
                             int lineNumber,
                             OpmLog::MessageType messageType,
                             const std::string& description) {
@@ -91,25 +91,25 @@ void Logger::addMessage(const std::string& fileName,
     }
 }
 
-void Logger::addNote(const std::string& fileName,
+void MessageCounter::addNote(const std::string& fileName,
                         int lineNumber,
                         const std::string& description) {
     addMessage(fileName, lineNumber, OpmLog::Note, description);
 }
 
-void Logger::addWarning(const std::string& fileName,
+void MessageCounter::addWarning(const std::string& fileName,
                            int lineNumber,
                            const std::string& description) {
     addMessage(fileName, lineNumber, OpmLog::Warning, description);
 }
 
-void Logger::addError(const std::string& fileName,
+void MessageCounter::addError(const std::string& fileName,
                          int lineNumber,
                          const std::string& description) {
     addMessage(fileName, lineNumber, OpmLog::Error, description);
 }
 
-void Logger::clear()
+void MessageCounter::clear()
 {
     m_numErrors = 0;
     m_numWarnings = 0;
@@ -118,7 +118,7 @@ void Logger::clear()
     m_messages.clear();
 }
 
-void Logger::append(const Logger &other)
+void MessageCounter::append(const MessageCounter &other)
 {
     for (size_t i = 0; i < other.size(); ++i) {
         addMessage(other.getFileName(i),
@@ -128,27 +128,27 @@ void Logger::append(const Logger &other)
     }
 }
 
-const std::string& Logger::getFileName(size_t msgIdx) const {
+const std::string& MessageCounter::getFileName(size_t msgIdx) const {
     assert(msgIdx < size());
     return std::get<0>(m_messages[msgIdx]);
 }
 
-int Logger::getLineNumber(size_t msgIdx) const {
+int MessageCounter::getLineNumber(size_t msgIdx) const {
     assert(msgIdx < size());
     return std::get<1>(m_messages[msgIdx]);
 }
 
-OpmLog::MessageType Logger::getMessageType(size_t msgIdx) const {
+OpmLog::MessageType MessageCounter::getMessageType(size_t msgIdx) const {
     assert(msgIdx < size());
     return std::get<2>(m_messages[msgIdx]);
 }
 
-const std::string& Logger::getDescription(size_t msgIdx) const {
+const std::string& MessageCounter::getDescription(size_t msgIdx) const {
     assert(msgIdx < size());
     return std::get<3>(m_messages[msgIdx]);
 }
 
-const std::string Logger::getFormattedMessage(size_t msgIdx) const {
+const std::string MessageCounter::getFormattedMessage(size_t msgIdx) const {
     std::ostringstream oss;
     if (getLineNumber(msgIdx) > 0) {
         oss << getFileName(msgIdx) << ":"
@@ -170,7 +170,7 @@ const std::string Logger::getFormattedMessage(size_t msgIdx) const {
     return oss.str();
 }
 
-void Logger::printAll(std::ostream& os, size_t enabledTypes) const {
+void MessageCounter::printAll(std::ostream& os, size_t enabledTypes) const {
     for (size_t i = 0; i < size(); ++i)
         if (enabledTypes & getMessageType(i))
             os << getFormattedMessage(i) << "\n";
diff --git a/opm/parser/eclipse/Log/Logger.hpp b/opm/parser/eclipse/OpmLog/MessageCounter.hpp
similarity index 90%
rename from opm/parser/eclipse/Log/Logger.hpp
rename to opm/parser/eclipse/OpmLog/MessageCounter.hpp
index d8914326d..79bb6edfb 100644
--- a/opm/parser/eclipse/Log/Logger.hpp
+++ b/opm/parser/eclipse/OpmLog/MessageCounter.hpp
@@ -16,8 +16,8 @@
   You should have received a copy of the GNU General Public License
   along with OPM.  If not, see <http://www.gnu.org/licenses/>.
  */
-#ifndef OPM_LOGGER_HPP
-#define OPM_LOGGER_HPP
+#ifndef OPM_MESSAGECOUNTER_HPP
+#define OPM_MESSAGECOUNTER_HPP
 
 #include <iostream>
 #include <string>
@@ -32,11 +32,11 @@ namespace Opm {
  * \brief Provides a simple sytem for log message which are found by the
  *        Parser/Deck/EclipseState classes during processing the deck.
  */
-class Logger {
+class MessageCounter {
 public:
 
-    Logger();
-    Logger(std::ostream* os);
+    MessageCounter();
+    MessageCounter(std::ostream* os);
 
     void setOutStream(std::ostream* os);
 
@@ -66,7 +66,7 @@ public:
     const std::string& getDescription(size_t msgIdx) const;
 
     void clear();
-    void append(const Logger &other);
+    void append(const MessageCounter &other);
 
     /*!
      * \brief This method takes the information provided by the methods above and returns
@@ -102,8 +102,8 @@ private:
     mutable std::ostream* m_outStream;
 };
 
-typedef std::shared_ptr<Logger> LoggerPtr;
-typedef std::shared_ptr<const Logger> LoggerConstPtr;
+typedef std::shared_ptr<MessageCounter> MessageCounterPtr;
+typedef std::shared_ptr<const MessageCounter> MessageCounterConstPtr;
 } // namespace Opm
 
 #endif
diff --git a/opm/parser/eclipse/OpmLog/OpmLog.cpp b/opm/parser/eclipse/OpmLog/OpmLog.cpp
index 0016d3872..04134ab64 100644
--- a/opm/parser/eclipse/OpmLog/OpmLog.cpp
+++ b/opm/parser/eclipse/OpmLog/OpmLog.cpp
@@ -54,9 +54,9 @@ namespace Opm {
     }
 
     /*
-    std::shared_ptr<Logger> OpmLog::getLogger() {
+    std::shared_ptr<MessageCounter> OpmLog::getMessageCounter() {
           if (!m_logger)
-          m_logger.reset( new Logger() );
+          m_logger.reset( new MessageCounter() );
 
           return m_logger;
     }
@@ -64,7 +64,7 @@ namespace Opm {
 
     void OpmLog::addMessage(MessageType messageType , const std::string& message) {
         /*
-          auto logger = OpmLog::getLogger();
+          auto logger = OpmLog::getMessageCounter();
           logger->addMessage( "" , -1 , messageType , message );
         */
     }
@@ -72,5 +72,5 @@ namespace Opm {
 
 /******************************************************************/
 
-    //std::shared_ptr<Logger> OpmLog::m_logger;
+    //std::shared_ptr<MessageCounter> OpmLog::m_logger;
 }
diff --git a/opm/parser/eclipse/OpmLog/OpmLog.hpp b/opm/parser/eclipse/OpmLog/OpmLog.hpp
index 340ebb4b7..efed43347 100644
--- a/opm/parser/eclipse/OpmLog/OpmLog.hpp
+++ b/opm/parser/eclipse/OpmLog/OpmLog.hpp
@@ -27,7 +27,7 @@ namespace Opm {
 
 /*
   The OpmLog class is a fully static class which manages a proper
-  Logger instance.
+  MessageCounter instance.
 */
 
 
@@ -46,8 +46,8 @@ public:
     static std::string prefixMessage(MessageType messageType , const std::string& msg);
 private:
     /*
-      static std::shared_ptr<Logger> getLogger();
-      static std::shared_ptr<Logger> m_logger;
+      static std::shared_ptr<MessageCounter> getMessageCounter();
+      static std::shared_ptr<MessageCounter> m_logger;
     */
 };
 
diff --git a/opm/parser/eclipse/Parser/Parser.cpp b/opm/parser/eclipse/Parser/Parser.cpp
index 8d2ff1d42..f62ccf6e3 100644
--- a/opm/parser/eclipse/Parser/Parser.cpp
+++ b/opm/parser/eclipse/Parser/Parser.cpp
@@ -19,7 +19,7 @@
 
 #include <memory>
 
-#include <opm/parser/eclipse/Log/Logger.hpp>
+#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
 
 #include <opm/parser/eclipse/Parser/ParserIntItem.hpp>
 #include <opm/parser/eclipse/Parser/Parser.hpp>
@@ -33,7 +33,7 @@ namespace Opm {
 
     struct ParserState {
         DeckPtr deck;
-        Logger logger;
+        MessageCounter logger;
         boost::filesystem::path dataFile;
         boost::filesystem::path rootPath;
         std::map<std::string, std::string> pathMap;
@@ -91,7 +91,7 @@ namespace Opm {
      is retained in the current implementation.
      */
 
-    DeckPtr Parser::parseFile(const std::string &dataFileName, LoggerPtr logger) const {
+    DeckPtr Parser::parseFile(const std::string &dataFileName, MessageCounterPtr logger) const {
 
         std::shared_ptr<ParserState> parserState(new ParserState(dataFileName, DeckPtr(new Deck()), getRootPathFromFile(dataFileName)));
 
@@ -108,7 +108,7 @@ namespace Opm {
         return parserState->deck;
     }
 
-    DeckPtr Parser::parseString(const std::string &data, LoggerPtr logger) const {
+    DeckPtr Parser::parseString(const std::string &data, MessageCounterPtr logger) const {
 
         std::shared_ptr<ParserState> parserState(new ParserState(data, DeckPtr(new Deck())));
 
@@ -121,7 +121,7 @@ namespace Opm {
         return parserState->deck;
     }
 
-    DeckPtr Parser::parseStream(std::shared_ptr<std::istream> inputStream, LoggerPtr logger) const {
+    DeckPtr Parser::parseStream(std::shared_ptr<std::istream> inputStream, MessageCounterPtr logger) const {
         std::shared_ptr<ParserState> parserState(new ParserState(inputStream, DeckPtr(new Deck())));
 
         parseState(parserState);
diff --git a/opm/parser/eclipse/Parser/Parser.hpp b/opm/parser/eclipse/Parser/Parser.hpp
index 507b21280..857961b10 100644
--- a/opm/parser/eclipse/Parser/Parser.hpp
+++ b/opm/parser/eclipse/Parser/Parser.hpp
@@ -29,7 +29,7 @@
 
 #include <opm/json/JsonObject.hpp>
 
-#include <opm/parser/eclipse/Log/Logger.hpp>
+#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
 
 #include <opm/parser/eclipse/RawDeck/RawKeyword.hpp>
 #include <opm/parser/eclipse/Deck/Deck.hpp>
@@ -48,9 +48,9 @@ namespace Opm {
         Parser(bool addDefault = true);
 
         /// The starting point of the parsing process. The supplied file is parsed, and the resulting Deck is returned.
-        DeckPtr parseFile(const std::string &dataFile, LoggerPtr logger = std::make_shared<Logger>(&std::cout)) const;
-        DeckPtr parseString(const std::string &data, LoggerPtr logger = std::make_shared<Logger>(&std::cout)) const;
-        DeckPtr parseStream(std::shared_ptr<std::istream> inputStream, LoggerPtr logger = std::make_shared<Logger>(&std::cout)) const;
+        DeckPtr parseFile(const std::string &dataFile, MessageCounterPtr logger = std::make_shared<MessageCounter>(&std::cout)) const;
+        DeckPtr parseString(const std::string &data, MessageCounterPtr logger = std::make_shared<MessageCounter>(&std::cout)) const;
+        DeckPtr parseStream(std::shared_ptr<std::istream> inputStream, MessageCounterPtr logger = std::make_shared<MessageCounter>(&std::cout)) const;
 
         /// Method to add ParserKeyword instances, these holding type and size information about the keywords and their data.
         void addParserKeyword(ParserKeywordConstPtr parserKeyword);