
<p class="has-drop-cap wp-block-paragraph">1Solvallatränarna Mattias Djuse och Timo Nurmos är dominanterna bland tränarna när Margaretas Tidiga Unghästserie går in på tionde säsongen. Årets fyra första avdelningar avgörs på Solvalla i eftermiddag och Sulkysport har sammanställt vinnarna under de nio år som gått.<br>Totalt har det körts 144 lopp, men korats 146 vinnare! Det har nämligen slutat med dött lopp om segern vid två tillfällen och båda gångerna för de treåriga stona.</p>



<p class="wp-block-paragraph">Mattias Djuse har vunnit nästan av tionde lopp hittills och har hästar till start i tre av fyra divisioner idag. Det hetaste budet? Den efter fem starter obesegrade fyraåringen <strong>Cold Blaze</strong> (e. Sebastian K.).<br>– Känslan är god, han har varit fin i alla starter hittills och känns bra bra. Han tål att göra mycket själv. Näst senast på Solvalla fick han gå 1.200-1.300 meter utvändigt. Hästen kan öppna väldigt snabbt om Magnus vill det. Han gjorde det senast i några steg, men då ville inte Magnus fortsätta köra på honom när det var lång distans. Vi kör med samma balans och vagn som vi gjort och sparar växlarna, sade Mattias Djuse till V65 Direkt.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/01/coldblazemadmadam-617x333.jpg" alt="" class="wp-image-814372"/><figcaption class="wp-element-caption">Mattias Djuse-tränade Cold Blaze är obesegrad efter fem starter. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="wp-block-paragraph"><strong>Flest tränarsegrar i Margretas Tidiga Unghästserie</strong><br><em>Tränare, hemmabana – Antal segrar</em></p>



<ul class="wp-block-list">
<li>Mattias Djuse, Solvalla – 14</li>



<li>Timo Nurmos, Solvalla – 12</li>



<li>Roger Walmann, Solvalla – 7</li>



<li>Robert Bergh, Bergsåker – 6</li>



<li>Daniel Redén, Solvalla – 6</li>



<li>Svante Bårth, Solvalla – 5</li>



<li>Claes Sjöström, Solvalla – 5</li>



<li>Conrad Lugauer, Solvalla – 4</li>



<li>Stefa Melander, Solvalla – 4</li>



<li>Johan Untersteiner, Halmstad – 4</li>



<li>Helena Burman, Jägersro – 3</li>



<li>Joakim Elfving, Romme – 3</li>



<li>Alessandro Gocciadoro, Solvalla – 3</li>



<li>Adrian Kolgjini, Jägersro – 3</li>



<li>Reijo Liljendahl, Solvalla – 3</li>



<li>Stefan P Pettersson, Mantorp – 3</li>



<li>Jörgen Westholm, Solvalla – 3</li>



<li>Daniel Wäjersten, Bergsåker – 3</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">2Johan Untersteiner leder kuskligan inom V85 med sex vinster hittills i år, men idag står han över och semestrar söderut. Då kan Magnus A Djuse ta över tätpositionen. Magnus har redan vunnit fyra V85-lopp jämfört med Johans sex triumfer, men är streckfavorit bakom fem (!) av åtta styrningar idag.</p>



<p class="wp-block-paragraph"><strong>Handfullofdollar, Facetime Queen, Cold Blaze, Gliding Eagle</strong> och <strong>Rya Håleryd</strong> är Magnus fem favoriter på förhand. Och Handfullofdollars (e. Mister J.P.) är mest betrodd efter sex segrar på tio starter inför klass III-finalen.</p>



<p class="wp-block-paragraph">– Handfullofdollar hade tränat riktigt starkt inför loppet i lördags och visade ju då att han var bra i ordning. Han var inte helt bottnad i mål och det blev ett lämpligt lopp inför finalen. Det är en fin tävlingshäst som gör sitt bästa i alla lägen och han tål att göra en del själv. Han har haft fasta grejer på sig men möjligen om det kan bli urryckare för första gången, men vi får se, säger Mattias Djuse till Kanal75.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/02/07v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar på Solvalla.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3De i går kväll invigda olympiska spelen i italienska Milano och Cortina ruckar på starttiden för dagens V85-tävlingar på Solvalla, men sitt lugna i båten. Starttiden är flyttad sju minuter – från 16.10 till 16.17.</p>



<p class="wp-block-paragraph">Sulkysports expertpanel har synat omgången och ovan nämnde Cold Blaze får dubbla röster som förslag till enkelstreck, men det finns fler. Så här skriver Spelpoolens Patrik Kaldoyo om sin bästa spik:<br><em>”<strong>Eminent Kronos</strong> (V85-4). Startsnabb herre med perfekt utgångsläge. Segern senast togs från ledningen och mycket talar för repris nu trots tuffare emot. Spets och slut!”</em></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v85-tips-s-7-feb/" target="_blank" rel="noreferrer noopener">––> Här är experternas tips till Solvallas V85-omgång.</a></p>



<p class="wp-block-paragraph">Vill du spela andelsspel tillsammans med Sulkysports panel? Här finns olika alternativ:</p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/69ansspel/V85_2026-02-07_5_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos 69:ans Spel &#038; Tobak.</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/spelpoolen/V85_2026-02-07_5_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Spelpoolen.</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/simsalabim/V85_2026-02-07_5_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Simsalabim.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/12/prixocollard1-617x362.jpg" alt="" class="wp-image-670365"/><figcaption class="wp-element-caption">Working Class Hero vid en av sina tidigare segrar på Vincennes. Foto: Gerard Forni</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Dagens höjdare på Vincennes är Prix de Munich (€90.000) över 2.100 meter och 40.500 euro till vinnaren. Jörgen Westholm plockar ut sin topphäst <strong>Working Class Hero</strong> (e. Village Mystic), som vann i återkomsten till Vincennes i november men fått nöja sig med att sluta sexa, femma och fyra i de senaste starterna på kolstybben.<br>Nu har han dragit andraspår bakom bilen tillsammans med Mathieu Mottier och tillhör favoritskaran.</p>



<p class="wp-block-paragraph">Daniel Redén mönstrar <strong>Indy Rock</strong> (e. Readly Express), som tränaren själv hoppar upp bakom. Daniel gjorde comeback som kusk på Vincennes när han slutade fastlåst som sjua med Chestnut under Pd’A-helgen.<br>Indy Rock startar i det andra leder liksom exempelvis finska Derbyvinnaren <strong>Lightning Stride</strong> (e. Twister Bi) och tyske <strong>Jazzman</strong> (e. Niky).</p>



<p class="wp-block-paragraph">Maria Törnqvist-tränade <strong>Ture L.A.</strong> (e. Maharajah) svarade för en fin Vincennesdebut som tvåa i ett sulkylopp för tre veckor sedan. I Prix de Lisieux (€75.000) blir det debut i monté med Mathieu Mottier i sadeln. 2.850 meter är distansen och motståndarna är mee eller mindre montéspecialister. Som Thomas Levesque-tränade <strong>Jacaranda</strong> (e. Goetmals Wood) med sju raka sadelsegrar på Vincennes i bagaget.</p>



<p class="wp-block-paragraph">Sabine Kagebrant-tränade <strong>Love Bites</strong> (e. Greenshoe) fungerade inte alls i första starten på Vincennes förra helgen. I dagens Prix de Verneuil (€52.000) för femåriga ston handlar det om sulky för Love Bites, som körs av Gabriele Gelormini.</p>



<p class="wp-block-paragraph"><a href="https://www.letrot.com/courses/programme/2026-02-07/7500" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar på Vincennes.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5En avelslöpning i dess rätta bemärkelse. Lars Laumbs lopp för kallbod, som körts sedan slutet av 1930-talet, är nämligen enbart avelsgodkända hingstar och ston som är premierade får vara med! Hästar som tidigare vunnit Lars Laumbs lopp är dessutom utestängda.<br>Tre svenskfödda kallblod har vunnit det klassiska loppet: <strong>Listjärn</strong> (e. Sabin) 1985, <strong>Järvsöfaks</strong> (e. Trollfaks) 2001 och <strong>Fakse</strong> (e. Järvsöfaks) 2007.</p>



<p class="wp-block-paragraph">Ikväll avgörs årets upplaga på Bjerke, där sju hingstar och ett sto slåss om förstapriset på 125.000 norska kronor från tre volter över lång distans.</p>



<p class="wp-block-paragraph">Jan-Olov Persson, som står bakom två av tre svenska vinnare i loppet, sänder en duo till Bjerke i <strong>Oppgårdsdrängen</strong> (e. Tekno Odin) och <strong>Våler Nikolai</strong> (e. Åsajerven). Oppgårdsdrängen tjänade mest av alla svensktränade kallblod förra året och vann åtta lopp. Årets säsong inleddes med seger på Bergsåker, men nu ställs han inför en tuff uppgift när han ska plocka in 20 meter på segermaskinen <strong>Ness Tjo Tyr</strong> (e. Moe Odin).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/11/oppgardsdrangen-617x333.jpg" alt="" class="wp-image-790731"/><figcaption class="wp-element-caption">Oppgårdsdrängen och Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph"><strong>Lars Laumbs lopp, Bjerke lördag</strong><br>2.640 meter voltstart<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>Hafell Bris</strong> (e. Stiv Kuling) – Gunnar Austevoll <br><em>2.660 meter:</em></li>



<li><strong>Ness Tjo Tyr</strong> (e. Moe Odin) – Björn Steine</li>



<li><strong>Fyri</strong> (e. Tekno Odin) – Vidar Hop</li>



<li><strong>Alm Kevin</strong> (e. Lome Brage) – Åsbjörn Tengsareid</li>



<li><strong>Voje Dino</strong> (e. Åsajerven) – Lars Anvar Kolle <br><em>2.680 meter:</em></li>



<li><strong>Oppgårdsdrängen</strong> (e. Tekno Odin) – Dag-Sveinung Dalen</li>



<li><strong>Grisle Tore G.L.</strong> (e. Horgen Tore) – Per Vetle Kals</li>



<li><strong>Våler Nikolai</strong> (e. Åsajerven) – Tom Erik Solberg</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">6Finska huvudstadsbanan Vermo bjuder också på penningstinna tävlingar idag. Hevari Winter Bonus-finalen för ston bjuder hela 20.000 euro till vinnaren.</p>



<p class="wp-block-paragraph">Fyra försök kördes för drygt två veckor sedan och en av vinnarna var svenskfödda <strong>Minerva Sisu</strong> (e. Hayden Hanover, som travade 1.15,0a/2.100 meter då. Nu inleder stoet från innerspår bakom bilen tillsammans med Tuukka Varis.<br>Övriga försöksvinnare var <strong>Herbie Malibu</strong> (e. Zola Boko) på 1.15,0a, <strong>Green River&#8217;s Zack</strong> (er. Jontte Boy) på 1.14,3a och <strong>Ransacker</strong> (e. Make It Happen) på 1.15,4a. Ytterligare ett svenskfött sto nådde final, Uncle Lasse-dottern Flaps Out.</p>



<p class="wp-block-paragraph">Gulddivisionen med 8.000 euro i förstapris sex sex av elva hästar födda i Sverige, bland annat uppstickaren <strong>Zebulon</strong> (e. Quite Easy), som vann fyra av fem starter i december-januari.</p>



<p class="wp-block-paragraph"><a href="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5IXzA3LjAyLjIwMjYucGRm&#038;m=3hfI3oOSloKN1E%2BwiJ5dPnoZj7Y%3D&#038;service=pdftmp" target="_blank" rel="noreferrer noopener">Här är startlistorna till Vermos tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7Storstjärnan <strong>Keayang Zahara</strong> (e. Volstead) lämnar fältet öppet i Kilmore Trotters Cup ($75.000) idag på Kilmore och lägger allt krut på försök- och finalloppet The Great Southern Star ($250.000) nästa helg. <br>Skulle det femåriga stoet lyckas vinna finalen i The Great Southern Star väntar – förutom förstapriset på 142.500 dollar – en bonus på 500.000 dollar om hon tar hem The Summer of Glory. I den serien har Keayang Zahara vunnit Ballarat Trotters Cup ($75.000), Maori Mile ($100.000) och Cranbourne Trotters Cup ($75.000). </p>



<p class="wp-block-paragraph">Bland de startanmälda idag finns tvåan <strong>Rockinwithattitude</strong> (e. Aldebaran Eagle) från både Ballarat Trotters Cup och Cranbourne Trotters Cup. </p>



<p class="wp-block-paragraph"><strong>Kilmore Trotters Cup ($75.000)</strong><br>2.180 meter autostart:<br><em>Häst (far) – Körsven</em></p>



<ol class="wp-block-list">
<li><strong>Jilliby Ballerini</strong> (e. Majestic Son) – Jason Lee</li>



<li><strong>Aldebaran Acrux</strong> (e. Chapter Seven) – Tayla French</li>



<li><strong>Jilliby Dreamlover</strong> (e. Love You) – Glen Craven</li>



<li><strong>Im Bobby</strong> (e. Majestic Son) – James Herbertson</li>



<li><strong>Ebonys Avenger</strong> (e. Kvintet Avenger) – Jordan Leedham</li>



<li><strong>Rockinwithattitude</strong> (e. Aldebaran Eagle) – David Miles</li>



<li><strong>Arcee Phoenix</strong> (e. Trixton) – Chris Svanosio</li>



<li><strong>Tweedlee</strong> (e. Superfast Stuart) – Anthony Butt</li>



<li><strong>El Resamo</strong> (e. Red Samurai) – Michael Bellman</li>



<li><strong>Gotfeelingsyouknow</strong> (e. Majestic Son) – Ross Payne</li>



<li><strong>Nephew of Sonoko</strong> (e. Danny Bouchea) – Ross Graham</li>



<li><strong>Avant Guard</strong> (e. Used to Me) – Ellen Tormey</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
Kungarna i Margareta-serien
Tränarna som vunnit flest Margareta-lopp. Westholm mot Redén i storlopp på Vincennes. Klassikern där tidigare vinnare inte får vara med. Segermaskin lämnar fältet öppet.
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
