As far as I know (I’m no expert), SOLID principles do not tell anything about state. They should be applicable as well in a functional programming languages. They’re more advice about how to achieve modularity.
Some of them are rather obvious or at least well-known. Single-responsibility is the UNIX principle “do one thing and do it well”, which is even more popular in functional languages where “composition” is widely used, similarly. The Interface Segregation Principle is very natural as well (have your interfaces modular and keep orthogonal concepts separated). Finally, Dependency Inversion is just a name for “abstraction” and is omnipresent in functional programming.
The “OL” principles, Open/Closed and LSP, are more oriented towards languages based upon inheritance as a core software engineering concept. Functional languages values/modules do not have open recursion by default, so “implementation inheritance” is only used in very specific cases. Composition is preferred. I’m not sure how you should interpret the Open/Closed principle in that setting. You may consider it is about encapsulation, which functional programs also use a lot, using abstract types and such.
Finally, the Liskov Substitution Principle may seem to be about inheritance. Functional languages do not always use subtyping, but when they do it is indeed assumed that “derived types” should preserve the specification of “base types”. Functional programmers are of course careful to specify and respect the interface and properties of their programs, modules etc., and may use algebraic reasoning (this is equivalent to this so I can substitute…) based on those specifications when programming, refactoring, etc. However, once you get rid of the “inheritance by default” idea, you have much less problems of interface violations, so LSP is not emphasized as a vital safeguard as it is in OOP.