diff --git a/include/openmc/particle.h b/include/openmc/particle.h
index 8143ee5a30..2917b45e4a 100644
--- a/include/openmc/particle.h
+++ b/include/openmc/particle.h
@@ -34,12 +34,6 @@ namespace openmc {
 // use to store the bins for delayed group tallies.
 constexpr int MAX_DELAYED_GROUPS {8};
 
-// Maximum number of lost particles
-constexpr int MAX_LOST_PARTICLES {10};
-
-// Maximum number of lost particles, relative to the total number of particles
-constexpr double REL_MAX_LOST_PARTICLES {1.0e-6};
-
 constexpr double CACHE_INVALID {-1.0};
 
 //==============================================================================
diff --git a/include/openmc/settings.h b/include/openmc/settings.h
index cbc0c488b9..2b4203646f 100644
--- a/include/openmc/settings.h
+++ b/include/openmc/settings.h
@@ -63,10 +63,12 @@ extern std::string path_source;
 extern std::string path_sourcepoint;      //!< path to a source file
 extern "C" std::string path_statepoint;   //!< path to a statepoint file
 
-extern "C" int32_t n_batches;      //!< number of (inactive+active) batches
-extern "C" int32_t n_inactive;     //!< number of inactive batches
-extern "C" int32_t gen_per_batch;  //!< number of generations per batch
-extern "C" int64_t n_particles;    //!< number of particles per generation
+extern "C" int32_t n_batches;                //!< number of (inactive+active) batches
+extern "C" int32_t n_inactive;               //!< number of inactive batches
+extern "C" int32_t max_lost_particles;     //!< maximum number of lost particles
+extern double rel_max_lost_particles;   //!< maximum number of lost particles, relative to the total number of particles
+extern "C" int32_t gen_per_batch;            //!< number of generations per batch
+extern "C" int64_t n_particles;              //!< number of particles per generation
 
 
 extern int64_t max_particles_in_flight; //!< Max num. event-based particles in flight
diff --git a/openmc/lib/settings.py b/openmc/lib/settings.py
index 275c73a934..68d68c29e0 100644
--- a/openmc/lib/settings.py
+++ b/openmc/lib/settings.py
@@ -22,6 +22,8 @@ class _Settings(object):
     entropy_on = _DLLGlobal(c_bool, 'entropy_on')
     generations_per_batch = _DLLGlobal(c_int32, 'gen_per_batch')
     inactive = _DLLGlobal(c_int32, 'n_inactive')
+    max_lost_particles = _DLLGlobal(c_int32, 'max_lost_particles')
+    rel_max_lost_particles = _DLLGlobal(c_double, 'rel_max_lost_particles')
     particles = _DLLGlobal(c_int64, 'n_particles')
     restart_run = _DLLGlobal(c_bool, 'restart_run')
     run_CE = _DLLGlobal(c_bool, 'run_CE')
diff --git a/openmc/settings.py b/openmc/settings.py
index eb2f926f3a..794c97b618 100644
--- a/openmc/settings.py
+++ b/openmc/settings.py
@@ -58,6 +58,10 @@ class Settings(object):
         history-based parallelism.
     generations_per_batch : int
         Number of generations per batch
+    max_lost_particles : int
+        Maximum number of lost particles       
+    rel_max_lost_particles : int
+        Maximum number of lost particles, relative to the total number of particles      
     inactive : int
         Number of inactive batches
     keff_trigger : dict
@@ -176,6 +180,8 @@ class Settings(object):
         self._batches = None
         self._generations_per_batch = None
         self._inactive = None
+        self._max_lost_particles = None
+        self._rel_max_lost_particles = None
         self._particles = None
         self._keff_trigger = None
 
@@ -254,6 +260,14 @@ class Settings(object):
     def inactive(self):
         return self._inactive
 
+    @property
+    def max_lost_particles(self):
+        return self._max_lost_particles        
+
+    @property
+    def rel_max_lost_particles(self):
+        return self._rel_max_lost_particles         
+
     @property
     def particles(self):
         return self._particles
@@ -417,6 +431,19 @@ class Settings(object):
         cv.check_greater_than('inactive batches', inactive, 0, True)
         self._inactive = inactive
 
+    @max_lost_particles.setter
+    def max_lost_particles(self, max_lost_particles):
+        cv.check_type('max_lost_particles', max_lost_particles, Integral)
+        cv.check_greater_than('max_lost_particles', max_lost_particles, 0)
+        self._max_lost_particles = max_lost_particles        
+
+    @rel_max_lost_particles.setter
+    def rel_max_lost_particles(self, rel_max_lost_particles):
+        cv.check_type('rel_max_lost_particles', rel_max_lost_particles, Real)
+        cv.check_greater_than('rel_max_lost_particles', rel_max_lost_particles, 0)
+        cv.check_less_than('rel_max_lost_particles', rel_max_lost_particles, 1)
+        self._rel_max_lost_particles = rel_max_lost_particles          
+
     @particles.setter
     def particles(self, particles):
         cv.check_type('particles', particles, Integral)
@@ -763,6 +790,16 @@ class Settings(object):
             element = ET.SubElement(root, "inactive")
             element.text = str(self._inactive)
 
+    def _create_max_lost_particles_subelement(self, root):
+        if self._max_lost_particles is not None:
+            element = ET.SubElement(root, "max_lost_particles")
+            element.text = str(self._max_lost_particles)    
+
+    def _create_rel_max_lost_particles_subelement(self, root):
+        if self._rel_max_lost_particles is not None:
+            element = ET.SubElement(root, "rel_max_lost_particles")
+            element.text = str(self._rel_max_lost_particles)                     
+
     def _create_particles_subelement(self, root):
         if self._particles is not None:
             element = ET.SubElement(root, "particles")
@@ -1009,6 +1046,8 @@ class Settings(object):
             self._particles_from_xml_element(elem)
             self._batches_from_xml_element(elem)
             self._inactive_from_xml_element(elem)
+            self._max_lost_particles_from_xml_element(elem)
+            self._rel_max_lost_particles_from_xml_element(elem)
             self._generations_per_batch_from_xml_element(elem)
 
     def _run_mode_from_xml_element(self, root):
@@ -1031,6 +1070,16 @@ class Settings(object):
         if text is not None:
             self.inactive = int(text)
 
+    def _max_lost_particles_from_xml_element(self, root):
+        text = get_text(root, 'max_lost_particles')
+        if text is not None:
+            self.max_lost_particles = int(text)     
+
+    def _rel_max_lost_particles_from_xml_element(self, root):
+        text = get_text(root, 'rel_max_lost_particles')
+        if text is not None:
+            self.rel_max_lost_particles = float(text)                       
+
     def _generations_per_batch_from_xml_element(self, root):
         text = get_text(root, 'generations_per_batch')
         if text is not None:
@@ -1270,6 +1319,8 @@ class Settings(object):
         self._create_particles_subelement(root_element)
         self._create_batches_subelement(root_element)
         self._create_inactive_subelement(root_element)
+        self._create_max_lost_particles_subelement(root_element)
+        self._create_rel_max_lost_particles_subelement(root_element)
         self._create_generations_per_batch_subelement(root_element)
         self._create_keff_trigger_subelement(root_element)
         self._create_source_subelement(root_element)
@@ -1340,6 +1391,8 @@ class Settings(object):
         settings._particles_from_xml_element(root)
         settings._batches_from_xml_element(root)
         settings._inactive_from_xml_element(root)
+        settings._max_lost_particles_from_xml_element(root)
+        settings._rel_max_lost_particles_from_xml_element(root)
         settings._generations_per_batch_from_xml_element(root)
         settings._keff_trigger_from_xml_element(root)
         settings._source_from_xml_element(root)
diff --git a/openmc/statepoint.py b/openmc/statepoint.py
index 5802a74cae..84512d70e7 100644
--- a/openmc/statepoint.py
+++ b/openmc/statepoint.py
@@ -310,7 +310,7 @@ class StatePoint(object):
         if self.run_mode == 'eigenvalue':
             return self._f['n_inactive'][()]
         else:
-            return None
+            return None                  
 
     @property
     def n_particles(self):
diff --git a/src/particle.cpp b/src/particle.cpp
index 24bec111c1..d2d8b2e1b3 100644
--- a/src/particle.cpp
+++ b/src/particle.cpp
@@ -631,8 +631,8 @@ Particle::mark_as_lost(const char* message)
 
   // Abort the simulation if the maximum number of lost particles has been
   // reached
-  if (simulation::n_lost_particles >= MAX_LOST_PARTICLES &&
-      simulation::n_lost_particles >= REL_MAX_LOST_PARTICLES*n) {
+  if (simulation::n_lost_particles >= settings::max_lost_particles &&
+      simulation::n_lost_particles >= settings::rel_max_lost_particles*n) {
     fatal_error("Maximum number of lost particles has been reached.");
   }
 }
diff --git a/src/settings.cpp b/src/settings.cpp
index 5bd53de259..7808a9d0f6 100644
--- a/src/settings.cpp
+++ b/src/settings.cpp
@@ -79,6 +79,8 @@ std::string path_statepoint;
 
 int32_t n_batches;
 int32_t n_inactive {0};
+int32_t max_lost_particles {10};
+double rel_max_lost_particles {1.0e-6};
 int32_t gen_per_batch {1};
 int64_t n_particles {-1};
 
@@ -143,6 +145,16 @@ void get_run_parameters(pugi::xml_node node_base)
   }
   if (!trigger_on) n_max_batches = n_batches;
 
+  // Get max number of lost particles
+  if (check_for_node(node_base, "max_lost_particles")) {
+    max_lost_particles = std::stoi(get_node_value(node_base, "max_lost_particles"));
+  }  
+
+  // Get relative number of lost particles
+  if (check_for_node(node_base, "rel_max_lost_particles")) {
+    rel_max_lost_particles = std::stod(get_node_value(node_base, "rel_max_lost_particles"));
+  }    
+
   // Get number of inactive batches
   if (run_mode == RunMode::EIGENVALUE) {
     if (check_for_node(node_base, "inactive")) {
@@ -343,14 +355,18 @@ void read_settings_xml()
     // Read run parameters
     get_run_parameters(node_mode);
 
-    // Check number of active batches, inactive batches, and particles
+    // Check number of active batches, inactive batches, max lost particles and particles
     if (n_batches <= n_inactive) {
       fatal_error("Number of active batches must be greater than zero.");
     } else if (n_inactive < 0) {
       fatal_error("Number of inactive batches must be non-negative.");
     } else if (n_particles <= 0) {
       fatal_error("Number of particles must be greater than zero.");
-    }
+    } else if (max_lost_particles <= 0) {
+      fatal_error("Number of max lost particles must be greater than zero.");
+    } else if (rel_max_lost_particles <= 0.0 || rel_max_lost_particles >= 1.0) {
+      fatal_error("Relative max lost particles must be between zero and one.");
+    }       
   }
 
   // Copy random number seed if specified
diff --git a/tests/unit_tests/test_settings.py b/tests/unit_tests/test_settings.py
index 9c33f6a2d4..c3ff728798 100644
--- a/tests/unit_tests/test_settings.py
+++ b/tests/unit_tests/test_settings.py
@@ -9,6 +9,8 @@ def test_export_to_xml(run_in_tmpdir):
     s.generations_per_batch = 10
     s.inactive = 100
     s.particles = 1000000
+    s.max_lost_particles = 5
+    s.rel_max_lost_particles = 1e-4
     s.keff_trigger = {'type': 'std_dev', 'threshold': 0.001}
     s.energy_mode = 'continuous-energy'
     s.max_order = 5
@@ -62,6 +64,8 @@ def test_export_to_xml(run_in_tmpdir):
     assert s.generations_per_batch == 10
     assert s.inactive == 100
     assert s.particles == 1000000
+    assert s.max_lost_particles == 5
+    assert s.rel_max_lost_particles == 1e-4
     assert s.keff_trigger == {'type': 'std_dev', 'threshold': 0.001}
     assert s.energy_mode == 'continuous-energy'
     assert s.max_order == 5