OWL2 points to a world where a production rules or logic language is fronted by a macro language that lets you say something like
"x is a transitive property"
rather than write
"x(a,b) and x(b,c) implies x(a,c)"
In fact, many RDFS and OWL implementations work exactly that way. RDFS/OWL is designed to support data integration in the sense of "this predicate is an alias of that predicate" but aren't revolutionary because it lacks the ability to do things like
"CentigradeTemperature(x,T) implies KelvinTemperature(x,T+273.15)"
which ordinary production rules engines do easily. Many semantic web tools have such a production rules engine hidden inside (Jena/GraphDB/...) but production rules have resisted standardization.
Note that "Datalog", a subset of Prolog that is purely logical and doesn't have cuts and all of that awful stuff, has caught on, but there has never been a "Turbo Datalog" or "Common Datalog" because frequently Datalog-equivalent functionality gets build into semantic web tools, Datomic, or systems that don't claim any formal compatibility with anything else.
RDF suffered a lot because of RDF/XML where it was really unclear where RDF ended and XML started. Today there is Turtle and JSON-LD, both of which are pretty ergonomic.
One issue I see is that many companies have their own "semantic web"-like technologies which are their own secret sauce and competitive advantage (thus not shared) whereas there seems to be a huge amount of fear and loathing of the W3C standards process, especially amoung people who are veterans of it.
While many people like JSON-LD, if you see actual uses of it such as Google's corporate contacts ([1]), I can't help but think it merely adds to the already heavy "syntacticity" of the semantic stack. For me, JSON-LD feels like an appeasement to the JSON and pragmatic web developers crowd, but then its JSON gets very complicated/counter-intuitive and squeezes @type, @context and other meta-meta attributes into JSON which won't make pragmatist happy.
Personally, my go-to stack for logic has become Datalog and Prolog once again (unmatched in terms of minimalism, elegance, and power IMHO).
[1]: https://developers.google.com/search/docs/data-types/corpora...
Prolog, OTOH, is as minimalistic and pragmatic as ever, with many implementations around, based on an ISO standard even. There's a slowly evolving initiative to come up with an extended standard library across Prolog implementations (eg. Prolog Commons). Though as you might know, Prolog doesn't solve hard problems in itself; rather, it gives you a Turing-complete language based on backtracking, negation-as-failure, closed-world reasoning, and extra-logical mechanisms as primitives to build more interesting reasoning or planning/optimization problems on.