
<p class="wp-block-paragraph">– Robert ringde när jag satt på älgpass på förmiddagen och frågade om det var möjligt att köra, sade Micael Melander.</p>



<p class="wp-block-paragraph">När Robert Bergh inte kunde komma till Bergsåker tog Micael Melander vara på sin möjlighet i silver- mot gulddivsionen. Han lyckades försvara innerspåret med <strong>Nickel Occagnes </strong>(e. Titan d’Occagnes-Rosy Pierre) i ett lopp där både Shogun R.R. och Bright Star galopperade i första sväng.</p>



<p class="wp-block-paragraph">– Från början hade vi lite hjälp från Björn (Goop) och Parish Crook V.S. som kunde hålla ut de andra hästarna lite grann och in i kurvan gick det så pass fort att det var svårt att ta något på oss, fortsatte Melander.</p>



<p class="wp-block-paragraph">Väl i ledningen kunde ingen utmana och även om Parish Crooks V.S. fick chansen från rygg ledaren och Shogun R.R. toppspurtade var det ingen som kunde utmana. Segertiden blev 1.12,0a/2.140 meter och förstapriset 150.000 kronor.</p>



<p class="wp-block-paragraph">– En jättetrevlig häst, lugn och fin och det fanns mycket krafter kvar i sista sväng, konstaterade Micael Melander efter andra V85-segern för Nickel Occagnes i år.</p>



<h2 class="wp-block-heading">Dubbla Derbyvinnare</h2>



<p class="wp-block-paragraph">Nickel Occagnes är undan<strong> Rosy Pierre</strong> (e. Love You-Naomi November), 1.15,7/180.597 kr, och hon är halvsyster med holländska Derbyvinnarna <strong>Amour d’Occagnes</strong> (e. Diamant Gede), 1.10,8/€639.030, och <strong>Max Occagnes</strong> (e. Traders), 1.10,9/€175.412.</p>



<p class="wp-block-paragraph">Ostartade mormor <strong>Naomi November</strong> (e. Viking Kronos) ingår i samma syskonskara som <strong>Joli November</strong> (e. Texas), 1.15,3/€94.901. Mormorsmor <strong>Meadowbranch Grace</strong> (e. Speedy Crown), 1.12,7/€34.593, är helsyster med Per Erikssons Hambletonian-vinnare <strong>Prakas</strong>, 1.10,5*/1.633.188.</p>



<h2 class="wp-block-heading">”Tror vi kunde vunnit ändå”</h2>



<p class="wp-block-paragraph">Galopp med segern klar i <a href="https://sulkysport.se/tursam-lucka-gav-seger/" data-type="link" data-id="https://sulkysport.se/tursam-lucka-gav-seger/" target="_blank" rel="noopener">första V85-avdelningen</a>, men lite tur (?) med i spelet när ledande Nordic Choice såg ut att vara ”hemma” på upploppet innan han rullade över i passgång och felade bort sig.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/11/mayj.-617x387.png" alt="" class="wp-image-919431"/><figcaption class="wp-element-caption">May J. och Magnus A Djuse.</figcaption></figure>



<p class="wp-block-paragraph">– Marcus (Lilius) fick någon längd mitt i sista sväng, men jag tror att vi kunde vunnit ändå även om han inte galopperat, sade Magnus A Djuse.</p>



<p class="wp-block-paragraph">Från positionen utvändigt om ledaren blev det seger för Jörgen Westholm-tränade <strong>May J </strong>(e. Bold Eagle-Mellby Fashion) på 1.12,6a/1.640 meter i ett försök i stodivisionen sedan stallkamraten Nordic Choice galopperat.</p>



<p class="wp-block-paragraph">– En stor och fin häst som rör sig på ett fint sätt, fortsatte Djuse.</p>



<h2 class="wp-block-heading">Första segern på svensk mark</h2>



<p class="wp-block-paragraph">Överlägsen var norskfödde <strong>Briskeby Pilen</strong> (e. Åsajerven-Briskeby Frökna) för Örjan Kihlström i kallblodsdivisionen sedan ekipaget attackerat i tredjespår 1.300 kvar och tagit över ledningen 200 meter senare.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/11/briskebypilen-617x437.png" alt="" class="wp-image-919432"/><figcaption class="wp-element-caption">Briskeby Pilen och Örjan Kihlström vann i överlägsen stil. </figcaption></figure>



<p class="wp-block-paragraph">– Han drog bara iväg och sedan var Briskeby Pilen helt överlägsen. Bra för klassen är väl en passande benämning på den här hästen, sade Örjan Kihlström.</p>



<p class="wp-block-paragraph">Drygt 30-talet meter hade Guri Gjermundshaug-tränade Briskeby Pilen ner till måltvåan Grisle Kongen G.L. Segertiden skrevs till 1.24,1a/2.640 meter när den åttaårige hingsten tog sin andra triumf för året i 16:e starten och den första i karriären på svensk mark.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/11/edensodin-617x360.png" alt="" class="wp-image-919433"/><figcaption class="wp-element-caption">Edins Odin och Jörn Ivar Eilertsen.</figcaption></figure>



<p class="wp-block-paragraph">Helt ohotad var också en annan norskfödd travare. <strong>Edens Odin </strong>(e. Moe Odin-Högda Lilja) försvarade innerspåret i Brimsguttens Minne. Guli Em skuggade hela vägen, vreds ut 200 kvar och då svarade tolvårige Edens Odin med att gå undan till seger på 1.23,8/2.140 meter utan att pressas det minsta.</p>



<p class="wp-block-paragraph">– En otrolig häst och mycket krafter kvar, sade Jörn Ivar Eilertsen efter triumfen värd 200.000 kronor.</p>



<h2 class="wp-block-heading">”Aldrig någon fara på taket”</h2>



<p class="wp-block-paragraph"><strong>Tarte Tatin</strong> (e. Maharajah-Clean Cash) och Björn Goop snabbstartade till täten och sedan fick duon bestämma farten därframme. Första varvet gick inte fortare än 1.16,2 och inne på målrakan kunde ingen hota på 1.14,2/2.140 meter i ett försök i Diamantstoet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/11/tartetaton-617x309.png" alt="" class="wp-image-919434"/><figcaption class="wp-element-caption">Tarten Tatin och Björn Goop.</figcaption></figure>



<p class="wp-block-paragraph">– Hon gick undan väldigt enkelt över upploppet och det var aldrig någon fara på taket, sade Björn Goop om det Fredrik Wallin-tränade stoet.</p>



<h2 class="wp-block-heading">Trippel för Wäjersten</h2>



<p class="wp-block-paragraph">Ett läckert intryck gav <strong>Youans Son </strong>(e. Readly Express-Youana) i ett klass I-försök för sin tränare Daniel Wäjersten sedan de övertagit täten 2.250 meter före mål. På sista bortre långsidan skruvades tempot upp och på upploppet var den fyraårige valacken ensam på plan på 1.12,9a/2.640 meter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/11/skarmavbild20261107kl.17.17.54-617x342.png" alt="" class="wp-image-919436"/><figcaption class="wp-element-caption">Youans Son och Daniel Wäjersten. </figcaption></figure>



<p class="wp-block-paragraph">– Youans Son hade nog en av sina bättre dagar så här långt i karriären. Han var väldigt spänstig och fin och hade en hel del ogjort på banan, sade Daniel Wäjersten.</p>



<p class="wp-block-paragraph">Avrundade V85-omgången gjorde Daniel Wäjersten med treårige <strong>Turner Ale</strong> (e. Readly Express-Kristall Tilly) och han vann lika enkelt som Youans Son. Från ledningen vann han i ohotad stil på 1.13,6a/2.140 meter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/11/skarmavbild20261107kl.17.45.15-617x299.png" alt="" class="wp-image-919440"/><figcaption class="wp-element-caption">Turner Ale vid sin enkla seger. </figcaption></figure>



<p class="wp-block-paragraph">– Det var lite dramatik 900 kvar och jag fick hjärtat i halsgropen när han kotade över med ett bakben. Ibland kan det bli galopp, men det brukar gå vägen när man har en häst med bra motorik och det har verkligen Turner Ale. Nästa år tror jag att det blir riktigt bra utveckling i honom, sade Daniel Wäjersten.</p>



<p class="wp-block-paragraph">Utanför V85-kupongen tog Daniel Wäjerstens <strong>Bojje Express</strong> (e. Readly Express-Mandistar) tredje raka triumfen och är obesegrad. Han fick dock bekänna färg och höll knappt undan för utvändige Starstrike (e. S.J.’s Caviar) på 1.14,6/2.140 meter.</p>



<p class="wp-block-paragraph">– Det var två hästar som kämpade helhjärtat och sista 100 meterna stod det och vägde. Alla bitarna har fallit på plats och det kan bli en spännande nästa säsong. Det här var sista starten för året, sade Daniel Wäjersten.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<h2 class="wp-block-heading">Rätt V85-rad:</h2>



<p class="wp-block-paragraph">1-1-9-1-1-6-6-5</p>



<p class="wp-block-paragraph"><strong>Utdelning:</strong></p>



<p class="wp-block-paragraph"><strong>Åtta rätt: </strong>1.762 kr<br><strong>Sju rätt: </strong>25 kr<br><strong>Sex rätt: </strong>jackpot<br><strong>Fem rätt:</strong> jackpot</p>



<p class="wp-block-paragraph"><strong>Omsättning: </strong>97.113.276 kronor.<br><strong>Antal system: </strong>1.608.815 kr.</p>
