JavaScript circular linked list compatriot game
The Ouroboros

Your code is way too complex for the task 

The most obvious improvement is to remove the functions find, findPreviouse, and count

Why


Rather than hold the data each list item has, hold the current link. This means you dont need to find the item each time you move along the list
You can know the remaining number of links by counting each link removed so there is no need for the function count.
If you remove the next link in the sequence rather than the current you don't need to find the previous link as you already have that, thus you dont need findPreviouse.


Some more points


When doing a simple countdown use a while loop. eg while (n--) { is much simpler than for (let i = n; i &gt; 0; i--) {
Don't test for conditions if there is no need. In remove you have if (!(prevNode.next == this.head)) { which I can not work out why you have it there. Also it should have been written as if (prevNode.next !== this.head) {
You should use const when ever possible, only if the variable has to change should you use var or let
Always use === or !== never use == or !=
If you are defining a object use the prototype or define the properties as an object. Creating a list of unrelated function names and then adding them to the object at creation is a mess, a source of bugs from the inevitable naming conflicts.


eg

function LList() {
    this.head = new Node("head");
    this.head.next = this.head;    
}
LList.prototype = {
    remove(item) {
        // function body
    },
    findPrevious(item) {
        // function body
    },
    display() {
        // function body
    },
    count() {
        // function body
    },
    // and so on...
};


Rewrite

I think that the LList and Node objects are overkill for this problem. A simple ad-hock object can hold the item position and link to the next. You only need to hold the current node, and to determine when you have two left just count off each item as they are removed. 

function survivor(number, step) {
    var i = 0, current;
    const add = pos =&gt; {
        const link = {pos};
        if (current) {                 // check if not first item
            link.next = current.next;  // insert link to tail
            current.next = link;
        } else { link.next = link }    // first link points to self
        current = link;                // Hold current as head
    }
    const stepOverAndRemove = (link, n) =&gt; {
        while (--n) { link = link.next }   // do this n-1 times
        return link.next = link.next.next; // remove next link and return link after that
    }

    while (i &lt; number) { add(i++) }  // create list
    current = current.next;          // move to the start

    // remove every `step` item until only two remain
    while (number-- &gt; 2) { current = stepOverAndRemove(current, step) }

    // return the position of the remaining two        
    return [current.pos, current.next.pos];
}