diff --git a/lark/lark.py b/lark/lark.py
index 8799610..172b1b9 100644
--- a/lark/lark.py
+++ b/lark/lark.py
@@ -336,7 +336,8 @@ class Lark(Serialize):
         Useful for caching and multiprocessing.
         """
         data, m = self.memo_serialize([TerminalDef, Rule])
-        pickle.dump({'data': data, 'memo': m}, f)
+        pickle.dump({'data': data, 'memo': m}, f,
+                    protocol=pickle.HIGHEST_PROTOCOL)
 
     @classmethod
     def load(cls, f):
@@ -373,7 +374,8 @@ class Lark(Serialize):
             self._callbacks,
             self.options.postlex,
             self.options.transformer,
-            re_module
+            re_module,
+            self.options.debug
         )
         self.terminals = self.parser.lexer_conf.tokens
         self._terminals_dict = {t.name: t for t in self.terminals}
diff --git a/lark/parser_frontends.py b/lark/parser_frontends.py
index eb2b615..f48887c 100644
--- a/lark/parser_frontends.py
+++ b/lark/parser_frontends.py
@@ -82,11 +82,13 @@ class WithLexer(_ParserFrontend):
         self.postlex = lexer_conf.postlex
 
     @classmethod
-    def deserialize(cls, data, memo, callbacks, postlex, transformer, re_module):
+    def deserialize(cls, data, memo, callbacks, postlex, transformer, re_module,
+                    debug):
         inst = super(WithLexer, cls).deserialize(data, memo)
 
         inst.postlex = postlex
-        inst.parser = LALR_Parser.deserialize(inst.parser, memo, callbacks)
+        inst.parser = LALR_Parser.deserialize(inst.parser, memo, callbacks,
+                                              debug)
 
         terminals = [item for item in memo.values() if isinstance(item, TerminalDef)]
         inst.lexer_conf.callbacks = _get_lexer_callbacks(transformer, terminals)
diff --git a/lark/parsers/lalr_parser.py b/lark/parsers/lalr_parser.py
index cf6a4bf..433f3ef 100644
--- a/lark/parsers/lalr_parser.py
+++ b/lark/parsers/lalr_parser.py
@@ -23,10 +23,10 @@ class LALR_Parser(object):
         self.parser = _Parser(analysis.parse_table, callbacks, debug)
 
     @classmethod
-    def deserialize(cls, data, memo, callbacks):
+    def deserialize(cls, data, memo, callbacks, debug=False):
         inst = cls.__new__(cls)
         inst._parse_table = IntParseTable.deserialize(data, memo)
-        inst.parser = _Parser(inst._parse_table, callbacks)
+        inst.parser = _Parser(inst._parse_table, callbacks, debug)
         return inst
 
     def serialize(self, memo):
diff --git a/tests/test_cache.py b/tests/test_cache.py
index ca4d781..4a07d7a 100644
--- a/tests/test_cache.py
+++ b/tests/test_cache.py
@@ -86,6 +86,12 @@ class TestCache(TestCase):
             parser = Lark(g, parser='lalr', lexer=CustomLexer, cache=True)
             assert len(mock_fs.files) == 1
             assert parser.parse('a') == Tree('start', [])
+
+            # Test options persistence
+            mock_fs.files = {}
+            Lark(g, parser="lalr", debug=True, cache=True)
+            parser = Lark(g, parser="lalr", debug=True, cache=True)
+            assert parser.options.options['debug']
         finally:
             lark_module.FS = fs
 
@@ -93,6 +99,3 @@ class TestCache(TestCase):
 
 if __name__ == '__main__':
     main()
-
-
-
diff --git a/tests/test_trees.py b/tests/test_trees.py
index cca92f9..905ad5a 100644
--- a/tests/test_trees.py
+++ b/tests/test_trees.py
@@ -20,7 +20,7 @@ class TestTrees(TestCase):
 
     def test_pickle(self):
         s = copy.deepcopy(self.tree1)
-        data = pickle.dumps(s)
+        data = pickle.dumps(s, protocol=pickle.HIGHEST_PROTOCOL)
         assert pickle.loads(data) == s
 
     def test_repr_runnable(self):