diff --git a/opm/models/ncp/ncpnewtonmethod.hh b/opm/models/ncp/ncpnewtonmethod.hh
index 3a9e16cc6..b21760c1f 100644
--- a/opm/models/ncp/ncpnewtonmethod.hh
+++ b/opm/models/ncp/ncpnewtonmethod.hh
@@ -117,10 +117,10 @@ protected:
 
         // make sure that the error never grows beyond the maximum
         // allowed one
-        if (this->error_ > Parameters::get<TypeTag, Parameters::NewtonMaxError>())
+        if (this->error_ > Parameters::Get<Parameters::NewtonMaxError<Scalar>>())
             throw Opm::NumericalProblem("Newton: Error "+std::to_string(double(this->error_))+
                                         + " is larger than maximum allowed error of "
-                                        + std::to_string(Parameters::get<TypeTag, Parameters::NewtonMaxError>()));
+                                        + std::to_string(Parameters::Get<Parameters::NewtonMaxError<Scalar>>()));
     }
 
     /*!
diff --git a/opm/models/nonlinear/newtonmethod.hh b/opm/models/nonlinear/newtonmethod.hh
index 26101dd51..8cf451283 100644
--- a/opm/models/nonlinear/newtonmethod.hh
+++ b/opm/models/nonlinear/newtonmethod.hh
@@ -81,15 +81,6 @@ struct NewtonConvergenceWriter<TypeTag, TTag::NewtonMethod> { using type = NullC
 
 namespace Opm::Parameters {
 
-// set the abortion tolerance to some very large value. if not
-// overwritten at run-time this basically disables abortions
-template<class TypeTag>
-struct NewtonMaxError<TypeTag, Properties::TTag::NewtonMethod>
-{
-    using type = GetPropType<TypeTag, Properties::Scalar>;
-    static constexpr type value = 1e100;
-};
-
 template<class TypeTag>
 struct NewtonTargetIterations<TypeTag, Properties::TTag::NewtonMethod>
 { static constexpr int value = 10; };
@@ -164,7 +155,7 @@ public:
         Parameters::Register<Parameters::NewtonTolerance<Scalar>>
             ("The maximum raw error tolerated by the Newton"
              "method for considering a solution to be converged");
-        Parameters::registerParam<TypeTag, Parameters::NewtonMaxError>
+        Parameters::Register<Parameters::NewtonMaxError<Scalar>>
             ("The maximum error tolerated by the Newton "
              "method to which does not cause an abort");
     }
@@ -595,7 +586,7 @@ protected:
     {
         const auto& constraintsMap = model().linearizer().constraintsMap();
         lastError_ = error_;
-        Scalar newtonMaxError = Parameters::get<TypeTag, Parameters::NewtonMaxError>();
+        Scalar newtonMaxError = Parameters::Get<Parameters::NewtonMaxError<Scalar>>();
 
         // calculate the error as the maximum weighted tolerance of
         // the solution's residual
diff --git a/opm/models/nonlinear/newtonmethodparameters.hh b/opm/models/nonlinear/newtonmethodparameters.hh
index 35c16379c..742981c8c 100644
--- a/opm/models/nonlinear/newtonmethodparameters.hh
+++ b/opm/models/nonlinear/newtonmethodparameters.hh
@@ -27,6 +27,11 @@
 
 namespace Opm::Parameters {
 
+//! The maximum error which may occur in a simulation before the
+//! Newton method for the time step is aborted
+template<class Scalar>
+struct NewtonMaxError { static constexpr Scalar value = 1e100; };
+
 /*!
  * \brief The value for the error below which convergence is declared
  *
@@ -43,11 +48,6 @@ struct NewtonVerbose { static constexpr bool value = true; };
 //! gets written out to disk for every Newton iteration
 struct NewtonWriteConvergence { static constexpr bool value = false; };
 
-//! The maximum error which may occur in a simulation before the
-//! Newton method for the time step is aborted
-template<class TypeTag, class MyTypeTag>
-struct NewtonMaxError { using type = Properties::UndefinedProperty; };
-
 /*!
  * \brief The number of iterations at which the Newton method
  *        should aim at.