You can use a custom JsonConverter to do double duty in handling both the polymorphic event types and the varying JSON formats. Below is an example. It works by loading the data into a JObject, where it can read the $type property and instantiate the correct event type. From there, it will try to populate the event object from the JSON. If the Airport fails to deserialize, it will then attempt to read the legacy airport proprties and populate a new Airport instance from that.

class EventConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return typeof(BaseEvent).IsAssignableFrom(objectType);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        JObject obj = JObject.Load(reader);

        string type = (string)obj["$type"];
        BaseEvent baseEvent;
        if (type.Contains(nameof(TakeoffEvent)))
        {
            baseEvent = new TakeoffEvent();
        }
        else
        {
            baseEvent = new LandingEvent();
        }
        serializer.Populate(obj.CreateReader(), baseEvent);

        if (baseEvent.Airport == null)
        {
            baseEvent.Airport = new Airport
            {
                Name = (string)obj["AirportName"],
                Runway = (string)obj["AirportRunway"]
            };
        }
        return baseEvent;
    }

    public override bool CanWrite => false;

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

Note: this assumes your class structure actually looks like this:

class Airport
{
    public string Name { get; set; }
    public string Runway { get; set; }
}

class BaseEvent
{
    public Airport Airport { get; set; }
}

class TakeoffEvent : BaseEvent
{
    public DateTime TimeOfTakeoff { get; set; }
}

class LandingEvent : BaseEvent
{
    public DateTime TimeOfLanding { get; set; }
}

To use the converter, add it to the Converters collection in the JsonSerializerSettings, and pass the settings to DeserializeObject():

var settings = new JsonSerializerSettings
{
    TypeNameHandling = TypeNameHandling.Objects,
    Converters = new List<JsonConverter> { new EventConverter() }
};

var baseEvent = JsonConvert.DeserializeObject<BaseEvent>(json, settings);

Here is a working demo: https://dotnetfiddle.net/jSaq4T

See also: Adding backward compatibility support for an older JSON structure

Classes change, this kind of Json strings change and will get extra features in future versions. You'll keep adjusting your declarations. With Newtonsoft, you can add custom handlers for varying class inheritance and keep using deserialize, but you'll have to maintain that code.

For dynamic Json, I find it easier to use JObject, JArray and JToken instead, to freely parse a Json string. Especially if you're only interested in some of the fields.

I can only give you an example, I think this is (a little) related to your project, but not the same part (smiley)

I use below code to decode part of a glTF 3d-object file produced by Blender in MSFS-converted format. This Json-like format consists of sections. Each Json section looks something like this,

  "asset" : {
    "extensions" : {
        "ASOBO_normal_map_convention" : {
            "tangent_space_convention" : "DirectX"
        }
    },
    "generator" : "Extended Khronos glTF Blender I/O v1.0.0",
    "version" : "2.0"
  },

.. but these sections and their fields are mostly optional and in some GLtf's they are not filled in. It is not "serializable or deserializable" to classes.

I declare some

    public JObject AssetObject;

.. filling it in from Json string sJson as follows:

        dynamic stuff = JObject.Parse(sJson);
        var pp = stuff.Children();
        Dictionary<string, bool> d = new Dictionary<string, bool>();
        foreach (JProperty jo in pp) d[jo.Name] = true; // all sections

        string cSection= "asset";
        if (!d.ContainsKey(cSection)) { LogLine(98, "Warning: BPG Json has no " + cSection + " section."); return false; }
        else
        {
            AssetObject = (JObject)stuff[cSection];
            ParseGLBAsset();
        }

Notice the use of a dynamic declaration at first, a section will land in JObject via cast. I store the various parts of the section into string properties. The parse itself takes place in ParseGLBAsset(), this function looks as follows:

    public void ParseGLBAsset()
    {
        foreach (JProperty jbp in AssetObject.Children())
            if (jbp.Name == "generator")
            { GLBGenerator = jbp.Value.ToString(); }
            else
            if (jbp.Name == "extensions")
            {
                GLBAssetExtensions = jbp.Value.ToString(); 
                LogLine(0, "Asset extensions: " + GLBAssetExtensions);
            }
            else
              if (jbp.Name == "version")
            { GLBVersion = jbp.Value.ToString(); }
        LogLine(1, "Found asset.generator=" + GLBGenerator);
        LogLine(1, "Found asset.version=" + GLBVersion);

    }