You could adopt and extend the general approach from this answer to Deserializing polymorphic json classes without type information using json.net or this answer to How to call JsonConvert.DeserializeObject and disable a JsonConverter applied to a base type via [JsonConverter]? by creating a custom JsonConverter for List<IMachineInfo> that does the following:

1. Loads each array entry into a temporary JToken.
2. Tries to infer the item type from the parameters present.
3. Skips the array entry if the type cannot be inferred.

To do this, first introduce a generic base class converter as follows:

public abstract class JsonListItemTypeInferringConverterBase<TItem> : JsonConverter
{
    public override bool CanWrite { get { return false; } }

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

    protected abstract bool TryInferItemType(Type objectType, JToken json, out Type type);

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        // Get contract information
        var contract = serializer.ContractResolver.ResolveContract(objectType) as JsonArrayContract;
        if (contract == null || contract.IsMultidimensionalArray || objectType.IsArray)
            throw new JsonSerializationException(string.Format("Invalid array contract for {0}", objectType));

        if (reader.MoveToContent().TokenType == JsonToken.Null)
            return null;

        if (reader.TokenType != JsonToken.StartArray)
            throw new JsonSerializationException(string.Format("Expected {0}, encountered {1} at path {2}", JsonToken.StartArray, reader.TokenType, reader.Path));

        var collection = existingValue as IList<TItem> ?? (IList<TItem>)contract.DefaultCreator();

        // Process the collection items
        while (reader.Read())
        {
            switch (reader.TokenType)
            {
                case JsonToken.EndArray:
                    return collection;

                case JsonToken.Comment:
                    break;

                default:
                    {
                        var token = JToken.Load(reader);
                        Type itemType;
                        if (!TryInferItemType(typeof(TItem), token, out itemType))
                            break;
                        collection.Add((TItem)serializer.Deserialize(token.CreateReader(), itemType));
                    }
                    break;
            }
        }
        // Should not come here.
        throw new JsonSerializationException("Unclosed array at path: " + reader.Path);
    }

    public override bool CanConvert(Type objectType)
    {
        return objectType.IsAssignableFrom(typeof(List<TItem>));
    }
}

public static partial class JsonExtensions
{
    public static JsonReader MoveToContent(this JsonReader reader)
    {
        while ((reader.TokenType == JsonToken.Comment || reader.TokenType == JsonToken.None) && reader.Read())
            ;
        return reader;
    }
}

Then, make a concrete version that only deserializes list entries of type Machine1 as follows:

public class Machine1ListConverter<TMachineInfo> : JsonListItemTypeInferringConverterBase<TMachineInfo> where TMachineInfo : IMachineInfo
{
    protected override bool TryInferItemType(Type objectType, JToken json, out Type type)
    {
        var obj = json as JObject;
        if (obj != null && obj.GetValue("powerWatts", StringComparison.OrdinalIgnoreCase) != null)
        {
            type = typeof(Machine1);
            return true;
        }
        type = null;
        return false;
    }
}

And finally deserialize your JSON string as follows:

var settings = new JsonSerializerSettings
{
    Converters = { new Machine1ListConverter<IMachineInfo>() },
};
var list = JsonConvert.DeserializeObject<List<IMachineInfo>>(jsonString, settings);

Of if you want to deserialize to a concrete List<Machine1> do:

var settings = new JsonSerializerSettings
{
    Converters = { new Machine1ListConverter<Machine1>() },
};
var list = JsonConvert.DeserializeObject<List<Machine1>>(jsonString, settings);

Notes:

• The converter needs to be applied to the overall collection instead of the collection items because JsonConverter.ReadJson has no ability to skip the token currently being read and prevent its return value from being added to the containing object.

• To deserialize only the items of type Machine2 you could similarly create Machine2ListConverter in which TryInferItemType() checks for the presence of dbm.

• To deserialize you are calling

  JsonConvert.DeserializeObject<List<Machine1>>(@"C/Path/jsonfile", settings);
  

  But JsonConvert.DeserializeObject Method (String, JsonSerializerSettings) deserializes a JSON string, not a named file. To deserialize from a file see Deserialize JSON from a file.

Demo fiddle here.