diff --git a/neo/rawio/neuralynxrawio/ncssections.py b/neo/rawio/neuralynxrawio/ncssections.py
index cf3da6113..8eb4b98c1 100644
--- a/neo/rawio/neuralynxrawio/ncssections.py
+++ b/neo/rawio/neuralynxrawio/ncssections.py
@@ -37,6 +37,19 @@
 import math
 import numpy as np
 
+from enum import IntEnum, auto
+
+
+class AcqType(IntEnum):
+    PRE4 = auto()
+    BML = auto()
+    DIGITALLYNX = auto()
+    DIGITALLYNXSX = auto()
+    CHEETAH64 = auto()
+    RAWDATAFILE = auto()
+    CHEETAH560 = auto()
+    ATLAS = auto()
+    UNKNOWN = auto()
 
 class NcsSections:
     """
@@ -250,7 +263,7 @@ def build_for_ncs_file(ncsMemMap, nlxHdr, gapTolerance=None, strict_gap_mode=Tru
         acqType = nlxHdr.type_of_recording()
         freq = nlxHdr["sampling_rate"]
 
-        if acqType == "PRE4":
+        if acqType == AcqType.PRE4:
             # Old Neuralynx style with truncated whole microseconds for actual sampling. This
             # restriction arose from the sampling being based on a master 1 MHz clock.
             microsPerSampUsed = math.floor(NcsSectionsFactory.get_micros_per_samp_for_freq(freq))
@@ -266,7 +279,8 @@ def build_for_ncs_file(ncsMemMap, nlxHdr, gapTolerance=None, strict_gap_mode=Tru
             ncsSects.sampFreqUsed = sampFreqUsed
             ncsSects.microsPerSampUsed = microsPerSampUsed
 
-        elif acqType in ["DIGITALLYNX", "DIGITALLYNXSX", "CHEETAH64", "CHEETAH560", "RAWDATAFILE"]:
+        elif acqType in [AcqType.DIGITALLYNX, AcqType.DIGITALLYNXSX, AcqType.CHEETAH64,
+                          AcqType.CHEETAH560, AcqType.RAWDATAFILE]:
             # digital lynx style with fractional frequency and micros per samp determined from block times
             if gapTolerance is None:
                 if strict_gap_mode:
@@ -293,7 +307,7 @@ def build_for_ncs_file(ncsMemMap, nlxHdr, gapTolerance=None, strict_gap_mode=Tru
             ncsSects.sampFreqUsed = sampFreqUsed
             ncsSects.microsPerSampUsed = NcsSectionsFactory.get_micros_per_samp_for_freq(sampFreqUsed)
 
-        elif acqType == "BML" or acqType == "ATLAS":
+        elif acqType == AcqType.BML or acqType == AcqType.ATLAS:
             # BML & ATLAS style with fractional frequency and micros per samp
             if strict_gap_mode:
                 # this is the old behavior, maybe we could put 0.9 sample interval no ?
diff --git a/neo/rawio/neuralynxrawio/nlxheader.py b/neo/rawio/neuralynxrawio/nlxheader.py
index ea3afd01a..f643a3d52 100644
--- a/neo/rawio/neuralynxrawio/nlxheader.py
+++ b/neo/rawio/neuralynxrawio/nlxheader.py
@@ -1,14 +1,23 @@
 import datetime
+import dateutil
 from packaging.version import Version
 import os
 import re
 from collections import OrderedDict
 
+from neo.rawio.neuralynxrawio.ncssections import AcqType
+
 
 class NlxHeader(OrderedDict):
     """
     Representation of basic information in all 16 kbytes Neuralynx file headers,
     including dates opened and closed if given.
+
+    The OrderedDict contains entries for each property given in the header with '-' in front
+    of the key value as well as an 'ApplicationName', 'ApplicationVersion', 'recording_opened'
+    and 'recording_closed' entries. The 'InputRange', 'channel_ids', 'channel_names' and
+    'bit_to_microvolt' properties are set to lists of entries for each channel which may be
+    in the file.
     """
 
     HEADER_SIZE = 2**14  # Neuralynx files have a txt header of 16kB
@@ -22,7 +31,9 @@ def _to_bool(txt):
         else:
             raise Exception("Can not convert %s to bool" % txt)
 
-    # keys that may be present in header which we parse
+    # Keys that may be present in header which we parse. First entry of tuple is what is
+    # present in header, second entry is key which will be used in dictionary, third entry
+    # type the value will be converted to.
     txt_header_keys = [
         ("AcqEntName", "channel_names", None),  # used
         ("FileType", "", None),
@@ -71,65 +82,92 @@ def _to_bool(txt):
     # Filename and datetime may appear in header lines starting with # at
     # beginning of header or in later versions as a property. The exact format
     # used depends on the application name and its version as well as the
-    # -FileVersion property.
+    # -FileVersion property. Examples of each known case are shown below in comments.
     #
-    # There are 4 styles understood by this code and the patterns used for parsing
-    # the items within each are stored in a dictionary. Each dictionary is then
-    # stored in main dictionary keyed by an abbreviation for the style.
-    header_pattern_dicts = {
-        # BML
-        "bml": dict(
-            datetime1_regex=r"## Time Opened: \(m/d/y\): (?P<date>\S+)" r"  At Time: (?P<time>\S+)",
-            filename_regex=r"## File Name: (?P<filename>\S+)",
-            datetimeformat="%m/%d/%y %H:%M:%S.%f",
-        ),
-        # Cheetah after version 1 and before version 5
-        "bv5": dict(
-            datetime1_regex=r"## Time Opened: \(m/d/y\): (?P<date>\S+)" r"  At Time: (?P<time>\S+)",
-            filename_regex=r"## File Name: (?P<filename>\S+)",
-            datetimeformat="%m/%d/%Y %H:%M:%S.%f",
-        ),
-        # Cheetah version 5.4.0
-        "v5.4.0": dict(
-            datetime1_regex=r"## Time Opened \(m/d/y\): (?P<date>\S+)" r"  At Time: (?P<time>\S+)",
-            datetime2_regex=r"## Time Closed \(m/d/y\): (?P<date>\S+)" r"  At Time: (?P<time>\S+)",
-            filename_regex=r"## File Name: (?P<filename>\S+)",
-            datetimeformat="%m/%d/%Y %H:%M:%S.%f",
-        ),
-        # Cheetah version 5.6.0, some range of versions in between
-        "v5.6.0": dict(
-            datetime1_regex=r"## Time Opened: \(m/d/y\): (?P<date>\S+)" r" At Time: (?P<time>\S+)",
-            filename_regex=r"## File Name: (?P<filename>\S+)",
-            datetimeformat="%m/%d/%Y %H:%M:%S.%f",
-        ),
-        # Cheetah version 5 before and including v 5.6.4 as well as version 1
-        "bv5.6.4": dict(
-            datetime1_regex=r"## Time Opened \(m/d/y\): (?P<date>\S+)" r"  \(h:m:s\.ms\) (?P<time>\S+)",
-            datetime2_regex=r"## Time Closed \(m/d/y\): (?P<date>\S+)" r"  \(h:m:s\.ms\) (?P<time>\S+)",
-            filename_regex=r"## File Name (?P<filename>\S+)",
-            datetimeformat="%m/%d/%Y %H:%M:%S.%f",
-        ),
-        "neuraview2": dict(
-            datetime1_regex=r"## Date Opened: \(mm/dd/yyy\): (?P<date>\S+)" r" At Time: (?P<time>\S+)",
-            datetime2_regex=r"## Date Closed: \(mm/dd/yyy\): (?P<date>\S+)" r" At Time: (?P<time>\S+)",
-            filename_regex=r"## File Name: (?P<filename>\S+)",
-            datetimeformat="%m/%d/%Y %H:%M:%S",
-        ),
-        "peg": dict(
-            datetime1_regex=r"-TimeCreated (?P<date>\S+) (?P<time>\S+)",
-            datetime2_regex=r"-TimeClosed (?P<date>\S+) (?P<time>\S+)",
-            filename_regex=r'-OriginalFileName "?(?P<filename>\S+)"?',
-            datetimeformat=r"%Y/%m/%d %H:%M:%S",
-            datetime2format=r"%Y/%m/%d %H:%M:%S.%f",
-        ),
-        # Cheetah after v 5.6.4 and default for others such as Pegasus
-        "def": dict(
-            datetime1_regex=r"-TimeCreated (?P<date>\S+) (?P<time>\S+)",
-            datetime2_regex=r"-TimeClosed (?P<date>\S+) (?P<time>\S+)",
-            filename_regex=r'-OriginalFileName "?(?P<filename>\S+)"?',
-            datetimeformat="%Y/%m/%d %H:%M:%S",
-        ),
-    }
+    # There are now separate patterns for the in header line and in properties cases which cover
+    # the known variations in each case. They are compiled here once for efficiency.
+    openDatetime1_pat = re.compile(r"## (Time|Date) Opened:* \((m/d/y|mm/dd/yyy)\): (?P<date>\S+)"\
+                                      r"\s+(\(h:m:s\.ms\)|At Time:) (?P<time>\S+)")
+    openDatetime2_pat = re.compile(r"-TimeCreated (?P<date>\S+) (?P<time>\S+)")
+    closeDatetime1_pat = re.compile(r"## (Time|Date) Closed:* \((m/d/y|mm/dd/yyy)\): " \
+                                        r"(?P<date>\S+)\s+(\(h:m:s\.ms\)|At Time:) (?P<time>\S+)")
+    closeDatetime2_pat = re.compile(r"-TimeClosed (?P<date>\S+) (?P<time>\S+)")
+
+    # BML - example
+    # ######## Neuralynx Data File Header
+    # ## File Name: null
+    # ## Time Opened: (m/d/y): 12/11/15  At Time: 11:37:39.000
+
+    # Cheetah after version 1 and before version 5 - example
+    # ######## Neuralynx Data File Header
+    # ## File Name F:\2000-01-01_18-28-39\RMH3.ncs
+    # ## Time Opened (m/d/y): 1/1/2000  (h:m:s.ms) 18:28:39.821
+    # ## Time Closed (m/d/y): 1/1/2000  (h:m:s.ms) 9:58:41.322
+
+    # Cheetah version 4.0.2 - example
+    # ######## Neuralynx Data File Header
+    # ## File Name: D:\Cheetah_Data\2003-10-4_10-2-58\CSC14.Ncs
+    # ## Time Opened: (m/d/y): 10/4/2003  At Time: 10:3:0.578
+
+    # Cheetah version 5.4.0 - example
+    # ######## Neuralynx Data File Header
+    # ## File Name C:\CheetahData\2000-01-01_00-00-00\CSC5.ncs
+    # ## Time Opened (m/d/y): 1/01/2001  At Time: 0:00:00.000
+    # ## Time Closed (m/d/y): 1/01/2001  At Time: 00:00:00.000
+
+    # Cheetah version 5.5.1 - example
+    # ######## Neuralynx Data File Header
+    # ## File Name C:\CheetahData\2013-11-29_17-05-05\Tet3a.ncs
+    # ## Time Opened (m/d/y): 11/29/2013  (h:m:s.ms) 17:5:16.793
+    # ## Time Closed (m/d/y): 11/29/2013  (h:m:s.ms) 18:3:13.603
+
+    # Cheetah version 5.6.0 - example
+    # ## File Name: F:\processing\sum-big-board\252-1375\recording-20180107\2018-01-07_15-14-54\04. tmaze1-no-light-start To tmaze1-light-stop\VT1_fixed.nvt
+    # ## Time Opened: (m/d/y): 2/5/2018 At Time: 18:5:12.654
+
+    # Cheetah version 5.6.3 - example
+    # ######## Neuralynx Data File Header
+    # ## File Name C:\CheetahData\2016-11-28_21-50-00\CSC1.ncs
+    # ## Time Opened (m/d/y): 11/28/2016  (h:m:s.ms) 21:50:33.322
+    # ## Time Closed (m/d/y): 11/28/2016  (h:m:s.ms) 22:44:41.145
+
+    # Cheetah version 5.7.4 - example
+    # ######## Neuralynx Data File Header
+    # and then properties
+    # -OriginalFileName "C:\CheetahData\2017-02-16_17-55-55\CSC1.ncs"
+    # -TimeCreated 2017/02/16 17:56:04
+    # -TimeClosed 2017/02/16 18:01:18
+
+    # Cheetah version 6.3.2 - example
+    # ######## Neuralynx Data File Header
+    # and then properties
+    # -OriginalFileName "G:\CheetahDataD\2019-07-12_13-21-32\CSC1.ncs"
+    # -TimeCreated 2019/07/12 13:21:32
+    # -TimeClosed 2019/07/12 15:07:55
+
+    # Cheetah version 6.4.1dev - example
+    # ######## Neuralynx Data File Header
+    # and then properties
+    # -OriginalFileName "D:\CheetahData\2021-02-26_15-46-33\CSC1.ncs"
+    # -TimeCreated 2021/02/26 15:46:52
+    # -TimeClosed 2021/10/12 09:07:58
+
+    # neuraview version 2 - example
+    # ######## Neuralynx Data File Header
+    # ## File Name: L:\McHugh Lab\Recording\2015-06-24_18-05-11\NeuraviewEventMarkers-20151214_SleepScore.nev
+    # ## Date Opened: (mm/dd/yyy): 12/14/2015 At Time: 15:58:32
+    # ## Date Closed: (mm/dd/yyy): 12/14/2015 At Time: 15:58:32
+
+    # pegasus version 2.1.1 and Cheetah beyond version 5.6.4 - example
+    # ######## Neuralynx Data File Header
+    # and then properties
+    # -OriginalFileName D:\Pegasus Data\Dr_NM\1902\2019-06-28_17-36-50\Events_0008.nev
+    # -TimeCreated 2019/06/28 17:36:50
+    # -TimeClosed 2019/06/28 17:45:48
+
+    # regular expressions to match filename
+    filename_regex = [r"## File Name (?P<filename>\S+)",
+                      r'-OriginalFileName "?(?P<filename>\S+)"?']
 
     def __init__(self, filename, props_only=False):
         """
@@ -148,22 +186,15 @@ def __init__(self, filename, props_only=False):
             ValueError("Neuralynx files must start with 8 # characters.")
 
         self.read_properties(filename, txt_header)
+        numChidEntries = self.convert_channel_ids_names(filename)
+        self.setApplicationAndVersion()
+        self.setBitToMicroVolt()
+        self.setInputRanges(numChidEntries)
+        # :TODO: needs to also handle filename property
 
         if not props_only:
             self.readTimeDate(txt_header)
 
-    @staticmethod
-    def build_with_properties_only(filename):
-        """
-        Builds a version of the header without time and date or other validity checking.
-
-        Intended mostly for utilities but may also be useful for some recalcitrant header formats.
-
-        :param filename: name of Neuralynx file.
-        :return: NlxHeader with properties from header text
-        """
-        res = OrderedDict()
-
     def read_properties(self, filename, txt_header):
         """
         Read properties from header and place in OrderedDictionary which this object is.
@@ -183,25 +214,31 @@ def read_properties(self, filename, txt_header):
                 if type_ is not None:
                     value = type_(value)
                 self[name] = value
-        # if channel_ids or s not in self then the filename is used
-        name = os.path.splitext(os.path.basename(filename))[0]
-        # convert channel ids
-        if "channel_ids" in self:
-            chid_entries = re.findall(r"\S+", self["channel_ids"])
-            self["channel_ids"] = [int(c) for c in chid_entries]
-        else:
-            self["channel_ids"] = ["unknown"]
-        # convert channel names
-        if "channel_names" in self:
-            name_entries = re.findall(r"\S+", self["channel_names"])
-            if len(name_entries) == 1:
-                self["channel_names"] = name_entries * len(self["channel_ids"])
-            assert len(self["channel_names"]) == len(
-                self["channel_ids"]
-            ), "Number of channel ids does not match channel names."
-        else:
-            self["channel_names"] = ["unknown"] * len(self["channel_ids"])
-        # version and application name
+
+    def setInputRanges(self, numChidEntries):
+        if "InputRange" in self:
+            ir_entries = re.findall(r"\w+", self["InputRange"])
+            if len(ir_entries) == 1:
+                self["InputRange"] = [int(ir_entries[0])] * numChidEntries
+            else:
+                self["InputRange"] = [int(e) for e in ir_entries]
+            assert len(self["InputRange"]) == numChidEntries, \
+                "Number of channel ids does not match input range values."
+
+    def setBitToMicroVolt(self):
+        # convert bit_to_microvolt
+        if "bit_to_microVolt" in self:
+            btm_entries = re.findall(r"\S+", self["bit_to_microVolt"])
+            if len(btm_entries) == 1:
+                btm_entries = btm_entries * len(self["channel_ids"])
+            self["bit_to_microVolt"] = [float(e) * 1e6 for e in btm_entries]
+            assert len(self["bit_to_microVolt"]) == len( self["channel_ids"]), \
+                "Number of channel ids does not match bit_to_microVolt conversion factors."
+
+    def setApplicationAndVersion(self):
+        """
+        Set "ApplicationName" property and app_version attribute based on existing properties
+        """
         # older Cheetah versions with CheetahRev property
         if "CheetahRev" in self:
             assert "ApplicationName" not in self
@@ -214,157 +251,121 @@ def read_properties(self, filename, txt_header):
             assert len(match) == 1, "impossible to find application name and version"
             self["ApplicationName"], app_version = match[0]
         # BML Ncs file contain neither property, but 'NLX_Base_Class_Type'
-        elif "NLX_Base_Class_Type" in txt_header:
+        elif "NLX_Base_Class_Type" in self:
             self["ApplicationName"] = "BML"
-            app_version = "2.0"
-        # Neuraview Ncs file contained neither property nor
-        # NLX_Base_Class_Type information
+            app_version = "1.0"
+        # Neuraview Ncs file contained neither property nor NLX_Base_Class_Type information
         else:
             self["ApplicationName"] = "Neuraview"
             app_version = "2"
+
         if " Development" in app_version:
             app_version = app_version.replace(" Development", ".dev0")
+
         self["ApplicationVersion"] = Version(app_version)
-        # convert bit_to_microvolt
-        if "bit_to_microVolt" in self:
-            btm_entries = re.findall(r"\S+", self["bit_to_microVolt"])
-            if len(btm_entries) == 1:
-                btm_entries = btm_entries * len(self["channel_ids"])
-            self["bit_to_microVolt"] = [float(e) * 1e6 for e in btm_entries]
-            assert len(self["bit_to_microVolt"]) == len(
-                self["channel_ids"]
-            ), "Number of channel ids does not match bit_to_microVolt conversion factors."
-        if "InputRange" in self:
-            ir_entries = re.findall(r"\w+", self["InputRange"])
-            if len(ir_entries) == 1:
-                self["InputRange"] = [int(ir_entries[0])] * len(chid_entries)
-            else:
-                self["InputRange"] = [int(e) for e in ir_entries]
-            assert len(self["InputRange"]) == len(
-                chid_entries
-            ), "Number of channel ids does not match input range values."
 
-    def readTimeDate(self, txt_header):
+    def convert_channel_ids_names(self, filename):
         """
-        Read time and date from text of header appropriate for app name and version
+        Convert channel ids and channel name properties, if present.
 
-        :TODO: this works for current examples but is not likely actually related
-        to app version in this manner.
+        :return number of channel id entries
         """
-        an = self["ApplicationName"]
-        if an == "Cheetah":
-            av = self["ApplicationVersion"]
-            if av <= Version("2"):  # version 1 uses same as older versions
-                hpd = NlxHeader.header_pattern_dicts["bv5.6.4"]
-            elif av < Version("5"):
-                hpd = NlxHeader.header_pattern_dicts["bv5"]
-            elif av <= Version("5.4.0"):
-                hpd = NlxHeader.header_pattern_dicts["v5.4.0"]
-            elif av == Version("5.6.0"):
-                hpd = NlxHeader.header_pattern_dicts["v5.6.0"]
-            elif av <= Version("5.6.4"):
-                hpd = NlxHeader.header_pattern_dicts["bv5.6.4"]
-            else:
-                hpd = NlxHeader.header_pattern_dicts["def"]
-        elif an == "BML":
-            hpd = NlxHeader.header_pattern_dicts["bml"]
-            av = Version("2")
-        elif an == "Neuraview":
-            hpd = NlxHeader.header_pattern_dicts["neuraview2"]
-            av = Version("2")
-        elif an == "Pegasus":
-            hpd = NlxHeader.header_pattern_dicts["peg"]
-            av = Version("2")
+        # if channel_ids or names not in self then the filename is used for channel name
+        name = os.path.splitext(os.path.basename(filename))[0]
+
+        # convert channel ids
+        if "channel_ids" in self:
+            chid_entries = re.findall(r"\S+", self["channel_ids"])
+            self["channel_ids"] = [int(c) for c in chid_entries]
+        else:
+            self["channel_ids"] = ["unknown"]
+            chid_entries = []
+
+        # convert channel names
+        if "channel_names" in self:
+            name_entries = re.findall(r"\S+", self["channel_names"])
+            if len(name_entries) == 1:
+                self["channel_names"] = name_entries * len(self["channel_ids"])
+            assert len(self["channel_names"]) == len(
+                self["channel_ids"]
+            ), "Number of channel ids does not match channel names."
         else:
-            an = "Unknown"
-            av = "NA"
-            hpd = NlxHeader.header_pattern_dicts["def"]
+            self["channel_names"] = ["unknown"] * len(self["channel_ids"])
+
+        return len(chid_entries)
+
+    def readTimeDate(self, txt_header):
+        """
+        Read time and date from text of header
+        """
+
         # opening time
-        sr = re.search(hpd["datetime1_regex"], txt_header)
+        sr = NlxHeader.openDatetime1_pat.search(txt_header)
+        if not sr: sr=NlxHeader.openDatetime2_pat.search(txt_header)
         if not sr:
             raise IOError(
-                f"No matching header open date/time for application {an} " + f"version {av}. Please contact developers."
+                f"No matching header open date/time for application {self['ApplicationName']} " +
+                f"version {self['ApplicationVersion']}. Please contact developers."
             )
         else:
             dt1 = sr.groupdict()
-            try:  # allow two possible formats for date and time
-                self["recording_opened"] = datetime.datetime.strptime(
-                    dt1["date"] + " " + dt1["time"], hpd["datetimeformat"]
-                )
-            except:
-                try:
-                    self["recording_opened"] = datetime.datetime.strptime(
-                        dt1["date"] + " " + dt1["time"], hpd["datetime2format"]
-                    )
-                except:
-                    self["recording_opened"] = None
+            self['recording_opened'] = dateutil.parser.parse(f"{dt1['date']} {dt1['time']}")
 
         # close time, if available
-        if "datetime2_regex" in hpd:
-            sr = re.search(hpd["datetime2_regex"], txt_header)
-            if not sr:
-                raise IOError(
-                    f"No matching header close date/time for application {an} "
-                    + f"version {av}. Please contact developers."
-                )
-            else:
-                try:
-                    dt2 = sr.groupdict()
-                    self["recording_closed"] = datetime.datetime.strptime(
-                        dt2["date"] + " " + dt2["time"], hpd["datetimeformat"]
-                    )
-                except:
-                    self["recording_closed"] = None
+        sr = NlxHeader.closeDatetime1_pat.search(txt_header)
+        if not sr: sr=NlxHeader.closeDatetime2_pat.search(txt_header)
+        if sr:
+            dt2 = sr.groupdict()
+            self['recording_closed'] = dateutil.parser.parse(f"{dt2['date']} {dt2['time']}")
 
     def type_of_recording(self):
         """
         Determines type of recording in Ncs file with this header.
 
-        RETURN:
-            one of 'PRE4','BML','DIGITALLYNX','DIGITALLYNXSX','UNKNOWN'
+        RETURN: NcsSections.AcqType
         """
 
         if "NLX_Base_Class_Type" in self:
 
             # older style standard neuralynx acquisition with rounded sampling frequency
             if self["NLX_Base_Class_Type"] == "CscAcqEnt":
-                return "PRE4"
+                return AcqType.PRE4
 
             # BML style with fractional frequency and microsPerSamp
             elif self["NLX_Base_Class_Type"] == "BmlAcq":
-                return "BML"
+                return AcqType.BML
 
             else:
-                return "UNKNOWN"
+                return AcqType.UNKNOWN
 
         elif "HardwareSubSystemType" in self:
 
             # DigitalLynx
             if self["HardwareSubSystemType"] == "DigitalLynx":
-                return "DIGITALLYNX"
+                return AcqType.DIGITALLYNX
 
             # DigitalLynxSX
             elif self["HardwareSubSystemType"] == "DigitalLynxSX":
-                return "DIGITALLYNXSX"
+                return AcqType.DIGITALLYNXSX
 
             # Cheetah64
             elif self["HardwareSubSystemType"] == "Cheetah64":
-                return "CHEETAH64"
+                return AcqType.CHEETAH64
 
             # RawDataFile
             elif self["HardwareSubSystemType"] == "RawDataFile":
-                return "RAWDATAFILE"
+                return AcqType.RAWDATAFILE
 
             else:
-                return "UNKNOWN"
+                return AcqType.UNKNOWN
 
         elif "FileType" in self:
 
             if "FileVersion" in self and self["FileVersion"] in ["3.2", "3.3", "3.4"]:
-                return self["AcquisitionSystem"].split()[1].upper()
+                return AcqType[self["AcquisitionSystem"].split()[1].upper()]
 
             else:
-                return "CHEETAH560"  # only known case of FileType without FileVersion
+                return AcqType.CHEETAH560  # only known case of FileType without FileVersion
 
         else:
-            return "UNKNOWN"
+            return AcqType.UNKNOWN
diff --git a/neo/test/rawiotest/test_neuralynxrawio.py b/neo/test/rawiotest/test_neuralynxrawio.py
index c923b54ec..f604b2fb2 100644
--- a/neo/test/rawiotest/test_neuralynxrawio.py
+++ b/neo/test/rawiotest/test_neuralynxrawio.py
@@ -1,11 +1,15 @@
 import unittest
 
 import os
+from datetime import datetime
+
+import dateutil
 import numpy as np
+import re
 
 from neo.rawio.neuralynxrawio.neuralynxrawio import NeuralynxRawIO
 from neo.rawio.neuralynxrawio.nlxheader import NlxHeader
-from neo.rawio.neuralynxrawio.ncssections import NcsSection, NcsSections, NcsSectionsFactory
+from neo.rawio.neuralynxrawio.ncssections import AcqType, NcsSection, NcsSections, NcsSectionsFactory
 from neo.test.rawiotest.common_rawio_test import BaseTestRawIO
 
 import logging
@@ -173,24 +177,93 @@ def test_exclude_filenames(self):
         self.assertEqual(len(rawio.header["spike_channels"]), 8)
         self.assertEqual(len(rawio.header["event_channels"]), 0)
 
+    def test_keep_original_times(self):
+        # Cheetah_5.5.1 has .ncs, .nse and .nev files all with different start times for each:
+        # Events.nev  26122558117
+        # STet3a.nse  26122760712
+        # STet3b.nse  26122898212
+        # STet3a.ncs  26122557633
+        # STet3b.ncs  26122557633
+        dname = self.get_local_path("neuralynx/Cheetah_v5.5.1/original_data/")
+
+        # Without keep_original_times, the global_start_time will be the first time of any signal
+        # or spike or event in seconds, corresponding to the earliest value from STet3{a|b}.ncs.
+        rawio = NeuralynxRawIO(dirname=dname)
+        rawio.parse_header()
+        self.assertEqual(26122.557633, rawio.global_t_start)
+
+        # The first time in the first stream of signals will be 0, the time of the sample relative
+        # to global_t_start, in seconds.
+        self.assertEqual(0.0, rawio.get_signal_t_start(0, 0, 0))
+
+        # The first time for the first spike in integer µS from STet3a.nse. BaseRawIO has this be
+        # as close to the raw dataformat as possible, so in this case, that is the whole number of
+        # microseconds as recorded by Neuralynx.
+        ts = rawio.get_spike_timestamps(0,0,0)
+        self.assertEqual(26122760712, ts[0])
+
+        # After rescaling, the spike timestamps are in seconds relative to global_t_start, as
+        # per BaseRawIO.
+        rts = rawio.rescale_spike_timestamp(ts)
+        self.assertAlmostEqual((26122760712 - 26122557633)/1e6, rts[0], places=6)
+
+        # The first time for the first event in µS from Events.nev, also in whole number of
+        # microseconds as recorded by Neuralynx. Return is tuple of (timestamp, durations, labels).
+        ts = rawio.get_event_timestamps(0,0,0)
+        self.assertEqual(26122558117, ts[0][0])
+
+        # After rescaling, event timestamps also are in seconds relative to global_t_start.
+        rts = rawio.rescale_spike_timestamp(ts[0])
+        self.assertAlmostEqual((26122558117 - 26122557633)/1e6, rts[0], places=6)
+
+        # With keep_original_times=True, the global_start_time is now 0, as times returned below
+        # are original, but also relative to the global_t_start.
+        rawio = NeuralynxRawIO(dirname=dname, keep_original_times=True)
+        rawio.parse_header()
+        self.assertEqual(0.0, rawio.global_t_start)
+
+        # The first time in the first stream of signals will now be the first time of any signal
+        # or spike or event in seconds, corresponding to the earliest value from STet3{a|b}.ncs,
+        # relative to the global_start_time of 0.
+        self.assertEqual(26122.557633, rawio.get_signal_t_start(0, 0, 0))
+
+        # The first time for the first spike in integer µS from STet3a.nse. BaseRawIO has this be
+        # as close to the raw dataformat as possible, so in this case, that is the whole number of
+        # microseconds as recorded by Neuralynx.
+        ts = rawio.get_spike_timestamps(0,0,0)
+        self.assertEqual(26122760712, ts[0])
+
+        # After rescaling, the spike timestamps are now in seconds relative 0.
+        rts = rawio.rescale_spike_timestamp(ts)
+        self.assertAlmostEqual(26122760712/1e6, rts[0], places=6)
 
-class TestNcsRecordingType(TestNeuralynxRawIO, unittest.TestCase):
+        # The first time for the first event in µS from Events.nev, also in whole number of
+        # microseconds as recorded by Neuralynx. Return is tuple of (timestamp, durations, labels).
+        ts = rawio.get_event_timestamps(0,0,0)
+        self.assertEqual(26122558117, ts[0][0])
+
+        # After rescaling, event timestamps also are in seconds relative to 0..
+        rts = rawio.rescale_spike_timestamp(ts[0])
+        self.assertAlmostEqual(26122558117/1e6, rts[0], places=6)
+
+
+class TestNcsRecordingType(BaseTestRawIO, unittest.TestCase):
     """
     Test of decoding of NlxHeader for type of recording.
     """
-
+    rawioclass = NeuralynxRawIO
     entities_to_test = []
 
     ncsTypeTestFiles = [
-        ("neuralynx/Cheetah_v4.0.2/original_data/CSC14_trunc.Ncs", "PRE4"),
-        ("neuralynx/Cheetah_v5.4.0/original_data/CSC5_trunc.Ncs", "DIGITALLYNX"),
-        ("neuralynx/Cheetah_v5.5.1/original_data/STet3a.nse", "DIGITALLYNXSX"),
-        ("neuralynx/Cheetah_v5.5.1/original_data/Tet3a.ncs", "DIGITALLYNXSX"),
-        ("neuralynx/Cheetah_v5.6.3/original_data/CSC1.ncs", "DIGITALLYNXSX"),
-        ("neuralynx/Cheetah_v5.6.3/original_data/TT1.ntt", "DIGITALLYNXSX"),
-        ("neuralynx/Cheetah_v5.7.4/original_data/CSC1.ncs", "DIGITALLYNXSX"),
-        ("neuralynx/Cheetah_v6.3.2/incomplete_blocks/CSC1_reduced.ncs", "DIGITALLYNXSX"),
-        ("neuralynx/Pegasus_v2.1.1/Events_0008.nev", "ATLAS"),
+        ("neuralynx/Cheetah_v4.0.2/original_data/CSC14_trunc.Ncs", AcqType.PRE4),
+        ("neuralynx/Cheetah_v5.4.0/original_data/CSC5_trunc.Ncs", AcqType.DIGITALLYNX),
+        ("neuralynx/Cheetah_v5.5.1/original_data/STet3a.nse", AcqType.DIGITALLYNXSX),
+        ("neuralynx/Cheetah_v5.5.1/original_data/Tet3a.ncs", AcqType.DIGITALLYNXSX),
+        ("neuralynx/Cheetah_v5.6.3/original_data/CSC1.ncs", AcqType.DIGITALLYNXSX),
+        ("neuralynx/Cheetah_v5.6.3/original_data/TT1.ntt", AcqType.DIGITALLYNXSX),
+        ("neuralynx/Cheetah_v5.7.4/original_data/CSC1.ncs", AcqType.DIGITALLYNXSX),
+        ("neuralynx/Cheetah_v6.3.2/incomplete_blocks/CSC1_reduced.ncs", AcqType.DIGITALLYNXSX),
+        ("neuralynx/Pegasus_v2.1.1/Events_0008.nev", AcqType.ATLAS),
     ]
 
     def test_recording_types(self):
@@ -202,11 +275,11 @@ def test_recording_types(self):
             self.assertEqual(hdr.type_of_recording(), typeTest[1])
 
 
-class TestNcsSectionsFactory(TestNeuralynxRawIO, unittest.TestCase):
+class TestNcsSectionsFactory(BaseTestRawIO, unittest.TestCase):
     """
     Test building NcsBlocks for files of different revisions.
     """
-
+    rawioclass = NeuralynxRawIO
     entities_to_test = []
 
     def test_ncsblocks_partial(self):
@@ -323,11 +396,11 @@ def test_block_verify(self):
         self.assertTrue(NcsSectionsFactory._verifySectionsStructure(data1, nb1))
 
 
-class TestNcsSections(TestNeuralynxRawIO, unittest.TestCase):
+class TestNcsSections(BaseTestRawIO, unittest.TestCase):
     """
     Test building NcsBlocks for files of different revisions.
     """
-
+    rawioclass = NeuralynxRawIO
     entities_to_test = []
 
     def test_equality(self):
@@ -360,8 +433,9 @@ def test_equality(self):
         ns0.sampFreqUsed = 400
         self.assertNotEqual(ns0, ns1)
 
+class TestNlxHeader(BaseTestRawIO, unittest.TestCase):
+    rawioclass = NeuralynxRawIO
 
-class TestNlxHeader(TestNeuralynxRawIO, unittest.TestCase):
     def test_no_date_time(self):
         filename = self.get_local_path("neuralynx/NoDateHeader/NoDateHeader.nev")
 
@@ -370,10 +444,85 @@ def test_no_date_time(self):
 
         hdr = NlxHeader(filename, props_only=True)
 
-        self.assertEqual(len(hdr), 11)  # 9 properties plus channel_ids and channel_names
-        self.assertEqual(hdr["ApplicationName"], "Pegasus")
-        self.assertEqual(hdr["FileType"], "Event")
+        self.assertEqual(len(hdr), 11) # 9 properties plus channel_ids and channel_names
+        self.assertEqual(hdr['ApplicationName'], 'Pegasus')
+        self.assertEqual(hdr['FileType'], 'Event')
+
+    def test_neuraview2(self):
+        filename = self.get_local_path("neuralynx/Neuraview_v2/original_data/NeuraviewEventMarkers-sample.nev")
+        hdr = NlxHeader(filename)
+
+        self.assertEqual(datetime.datetime(2015,12,14, 15,58,32), hdr['recording_opened'])
+        self.assertEqual(datetime.datetime(2015,12,14, 15,58,32), hdr['recording_closed'])
+
+    # left in for possible future header tests
+    def get_text_header(self, filename):
+        with open(filename, "rb") as f:
+            txt_header = f.read(NlxHeader.HEADER_SIZE)
+        return txt_header.strip(b"\x00").decode("latin-1")
+
+    # left in for possible future header tests
+    def check_dateutil_parse(self, hdrTxt, openPat, closePat, openDate, closeDate):
+        mtch = openPat.search(hdrTxt)
+        self.assertIsNotNone(mtch)
+        dt = mtch.groupdict()
+        date = dateutil.parser.parse(f"{dt['date']} {dt['time']}")
+        self.assertEqual(openDate, date)
+        if closePat is not None:
+            mtch = closePat.search(hdrTxt)
+            self.assertIsNotNone(mtch)
+            dt = mtch.groupdict()
+            date = dateutil.parser.parse(f"{dt['date']} {dt['time']}")
+            self.assertEqual(closeDate, date)
+
+    def test_datetime_parsing(self):
+
+        # neuraview2
+        filename = self.get_local_path("neuralynx/Neuraview_v2/original_data/NeuraviewEventMarkers-sample.nev")
+        txt_header = self.get_text_header(filename)
+        self.check_dateutil_parse(txt_header, NlxHeader.openDatetime1_pat, NlxHeader.closeDatetime1_pat,
+                                  datetime.datetime(2015,12,14, 15,58,32),
+                                  datetime.datetime(2015,12,14, 15,58,32))
+        hdr = NlxHeader(filename)
+        self.assertEqual(datetime.datetime(2015,12,14, 15,58,32),
+                          hdr['recording_opened'])
+        self.assertEqual(datetime.datetime(2015,12,14, 15,58,32),
+                          hdr['recording_closed'])
+
+        # Cheetah 5.7.4 'inProps'
+        filename = self.get_local_path("neuralynx/Cheetah_v5.7.4/original_data/CSC1.ncs")
+        txt_header = self.get_text_header(filename)
+        self.check_dateutil_parse(txt_header, NlxHeader.openDatetime2_pat, NlxHeader.closeDatetime2_pat,
+                                  datetime.datetime(2017,2,16, 17,56,4),
+                                  datetime.datetime(2017,2,16, 18,1,18))
+        hdr = NlxHeader(filename)
+        self.assertEqual(datetime.datetime(2017,2,16, 17,56,4),
+                          hdr['recording_opened'])
+        self.assertEqual(datetime.datetime(2017,2,16, 18,1,18),
+                         hdr['recording_closed'])
 
+        # Cheetah 4.0.2
+        filename = self.get_local_path("neuralynx/Cheetah_v4.0.2/original_data/CSC14_trunc.Ncs")
+        txt_header = self.get_text_header(filename)
+        self.check_dateutil_parse(txt_header, NlxHeader.openDatetime1_pat, None,
+                                  datetime.datetime(2003,10,4, 10,3,0, 578000),
+                                  None)
+        hdr = NlxHeader(filename)
+        self.assertEqual(datetime.datetime(2003,10,4, 10,3,0, 578000),
+                         hdr['recording_opened'])
+        self.assertIsNone(hdr.get('recording_closed'))
+
+        # Cheetah 5.4.0 'openClosedInHeader'
+        filename = self.get_local_path("neuralynx/Cheetah_v5.4.0/original_data/CSC5_trunc.Ncs")
+        txt_header = self.get_text_header(filename)
+        self.check_dateutil_parse(txt_header, NlxHeader.openDatetime1_pat, NlxHeader.closeDatetime1_pat,
+                                  datetime.datetime(2001,1,1, 0,0,0, 0),
+                                  datetime.datetime(2001,1,1, 0,0,0, 0))
+        hdr = NlxHeader(filename)
+        self.assertEqual(datetime.datetime(2001,1,1, 0,0,0, 0),
+                         hdr['recording_opened'])
+        self.assertEqual(datetime.datetime(2001,1,1, 0,0,0, 0),
+                         hdr['recording_closed'])
 
 if __name__ == "__main__":
     unittest.main()