
<p class="has-drop-cap">1Fyra gånger har Stefan Melander tränat vinnaren av Årjängs Stora Sprinterlopp. <strong>Igor Brick</strong> (2000 och 2001), <strong>Nuncio</strong> (2016) och <strong>Milligan’s School</strong> (2020). I år har han tre chanser att plocka en femte titiel i värmlandsbanans storlopp som körts sedan 1952. <strong>Decision Maker</strong> (e. Nuncio), <strong>Click Bait</strong> (e. Cantab Hall) och <strong>Thereisnolimit</strong> (e. Nuncio) är hans bidrag.</p>



<p>Decision Maker vann spårlottningen med innerspår, medan startblixten Click Bait drog bakspår.<br>– Decision Maker är fin, spår ett kan vara knepigt, men hon är duktig och kan trampa iväg riktigt bra. Det var tufft för henne att hoppa rakt in i Elitloppet, men det är otrolig skillnad på spår sex (i Elitloppet) och ett och det ser spännande ut om hon inte behöver lägga den speeden, sade Stefan Melander till V65 Direkt.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/clickbaitmad-617x333.jpg" alt="" class="wp-image-477046"/><figcaption class="wp-element-caption">Click Bait. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Fast han håller Click Bait minst lika högt i eftermiddag:<br>– Från framspår hade jag sagt att han var stenklar. Den här sommaren är han i otroligt slag. Han håller superform och jag tor att han klarar ett ganska tufft lopp, men det gäller att han har en hygglig position efter 300 meter.</p>



<p>1.09,3a/1.640 meter är banrekordet i Årjäng. Värmlandsbanans storlopp för den äldre eliten brukar ofta bjuda på hög fart och åtta av de elva senaste vinnarna har tvingats trava 1.09-tider för att lägga beslag på lagerkransen. Visst finns det läge för en ny notering under 1.10-strecket i årets upplaga om vädrets makter är med. </p>



<p><strong>Snabbaste vinnarna i Årjängs Stora Sprinterlopp:</strong><br><em>År, vinnare (far) – Körsven (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2018 <strong>Nadal Broline</strong> (e. Yankee Glide) – Ulf Ohlsson (Reijo Liljendahl) – 1.09,3</li>



<li>2019 <strong>Uza Josselyn</strong> (e. Love You) – Erik Adielsson (Rene Aebischer) – 1.09,3</li>



<li>2013 <strong>Sebastian K.</strong> (e. Korean) – Åke Svanstedt – 1.09,6</li>



<li>2017 <strong>Dante Boko</strong> (e. Going Kronos) – Adrian Kolgjini (Lutfi Kolgjini) – 1.09,6</li>



<li>2016 <strong>Nuncio</strong> (e. Andover Hall) – Örjan Kihlström (Stefan Melander) – 1.09,7</li>



<li>2021 <strong>Vernissage Grif</strong> (e. Varenne) – Alessandro Gocciadoro – 1.09,7</li>



<li>2020 <strong>Milligan’s School</strong> (e. Yankee Glide) – Ulf Eriksson (Stefan Melander) – 1.09,8</li>



<li>2014 <strong>Magic Tonight</strong> (e. Andover Hall) – Johan Untersteiner (Roger Walmann) – 1.09,9</li>
</ul>



<p><strong>Fotnot: </strong>2018 var Propulsion först i mål, men fråndömdes segern i efterhand av Svensk Travsport.</p>



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



<p class="has-drop-cap">2Sulkysports tipsexpert streckar hälften av hästarna i Årjängs Stora Sprinterlopp som avslutar V75-kupongen. Istället inleds V75-förslaget med två singelstreck i början:<br><em>”Vi spelar ett ”omvänt tv-system” den här veckan och inleder med två singelstreck. <strong>In Love Mearas</strong> (V75-1) har finfina förutsättningar med bra spår över sprinterdistans i den första avdelningen. Sedan jagar <strong>Eminent Kronos</strong> (V75-2) revansch för galoppen i lördags. Vi tror han rundar fältet trots det sämsta läget.”</em></p>



<p>Daniel Redén tränar In Love Mearas (e. Cantab Hall), som faktiskt är segerlös efter fyra starter i år.<br>– Han gick fantastiskt bra senast, vi hade fräschat upp honom lite och det var en jäkla uppryckning mot gången innan. Det här ser riktigt spännande ut. På läge och hur han gick senast så är han väldigt intressant här. Kort distans är en fördel och vi ändrar inget, säger Daniel Redén på Stall Zets hemsida.</p>



<p><a href="https://sulkysport.se/spelstugan/v75-tips-arjang-13-juli/" target="_blank" rel="noreferrer noopener">––> Här är Sulkysports stora tipsgenomgång inför V75 i Årjäng.</a></p>



<p><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p><a href="https://www.atg.se/andelskungen/spel/206687_V75_2024-07-13_31_5">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206688_V75_2024-07-13_31_5">Sulkysport V75 UNIK exklusiv – 15 andelar á 150 kr/styck</a></p>



<p>Lördagskvällen avslutas i Bollnäs (start 18.30). Det drar ihop sig för Derby- och Derbystokval i Östersund den 25 juli och en häst som lär dyka upp där är Jan-Olov Persson-tränade stoet <strong>Järvsö Britt</strong> (e. Tekno Eld). Fyra segrar har det blivit på 13 starter, men även galopp i mer än hälften av sina framträdanden. Ikväll möter hon bara sju konkurrenter när Derbyformen ska vässas.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/07/240713.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/09/torbjornjansson-617x333.jpg" alt="" class="wp-image-213997"/><figcaption class="wp-element-caption">Torbjörn Jansson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">3På Solvalla den 14 oktober förra året tog en era slut. Efter 4.713 triumfer lade Torbjörn Jansson körhandskarna på hyllan sedan <strong>Bedazzled Sox</strong> (e. Brillantissime) suttit fart i finalen av Europaderbyt. Men idag gör Torbjörn comeback!</p>



<p>Det handlar om en annorlunda sådan i Årjäng, där Torbjörn är en av nio kuskar som kör speedrace med ponnys. Tre heat med tre hästar i varje, där vinnarna möts i en final över 100 meter (!) med autostart är förutsättningarna. Klockan 11.50 idag drar det igång.<br>Torbjörn kör ponnyn Feona och möter i sitt heat Tom Horpestad och Nellie Norsell. I heat två kör Adrian Solberg Akselsen, Jonas Ås och Frida Johansson, medan Thomas Uhrberg, Isabell Eriksson och Marie E Persson slåss om finalplats i sista heatet.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/10/meadowroadsulkysport20192.pdf" target="_blank" rel="noreferrer noopener">Här är Sulkysports stora intervju med Torbjörn Jansson om hans största stjärna: Elitloppsvinnaren Meadow Road.</a></p>



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



<p class="has-drop-cap">4Meadowlands bjuder inte bara på Stanley Dancer Memorial ($135.000) och Delvin Miller Memorial ($125.000) för treåringar i natt svensk tid, utan på årets högst doterade löpning. I Hambletonian Maturity ($425.000) för fyraåringar över distansen 1.810 meter. </p>



<p>Sex svensktränade travare tar plats, varav trion <strong>Best Friend Volo</strong> (e. Walner), <strong>Hasty Bid</strong> (e. My Mvp) och <strong>Winner’s Bet</strong> (e. Walner) selas ut från Nancy Takters stall. Åke Svanstedt kommer med duon <strong>Special Way</strong> (e. Walner) och <strong>Up Your Deo</strong> (e. Walner), medan Marcus Melander bidrar med <strong>Oh Well</strong> (e. Muscle Hill). </p>



<p>Nancy Takters Winner’s Bet – uppfödd av Lennart Ågren – har inlett året med tre raka segrar, dubbla försök och final i Graduate Series ($230.000) och sprungit in 159.250 dollar. </p>



<p><strong>Startlista Hambletonian Maturity ($425.000)</strong><br>Fyraåringar, 1.810 meter, autostart:<br><em>Namn (far) – Körsven</em></p>



<ol class="wp-block-list">
<li>Up Your Deo (e. Walner) – Åke Svanstedt</li>



<li>Call Me Goo (e. Googoo Gaagaa) – Andrew McCarthy</li>



<li>Ari Ferrari J (e. Walner) – Bob McClure</li>



<li>Bestfriend Volo (e. Walner) – Scott Zeron</li>



<li>Hasty Bid (e. My Mvp) – James MacDonald</li>



<li>Oh Well (e. Muscle Hill) – Todd McCarthy</li>



<li>Special Way (e. Walner) – Tim Tetrick</li>



<li>Helpfirstedition (e. Helpisontheway) – David Miller</li>



<li>Ghostly Casper (e. Resolve) – Louis-Philippe Roy</li>



<li>Chapercraz (e. Crazy Wow) – Yannick Gingras</li>



<li>Winner’s Bet (e. Walner) – Dexter Dunn</li>



<li>French Wine (e. Bar Hopping) – Andy Miller</li>
</ol>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/10/meadowroadsulkysport20192.pdf" target="_blank" rel="noreferrer noopener">Startlistor till samtliga lopp till lördagens tävlingar kan laddas ner här.</a></p>



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



<p class="has-drop-cap">5Fyra år i rad och sex av de åtta senaste upplagorna har det krävts en 1.09-tid för att vinna Enghiens stora sprinterlopp Prix de Washington (€120.000), där danska stoet <strong>Uza Josselyn</strong> (e. Love You) ståtar med löpningsrekordet 1.09,0ak från 2018. I eftermiddag tar nio franska travare plats bakom startbilen och det finns en hel del spännande namn.</p>



<p>Philippe Allaire rustar med fjolårets Elitloppsvinnare <strong>Hohneck</strong> (e. Royal Dream) och femårige <strong>Just A Gigolo</strong> (e. Boccador de Simm). Hohneck har haft tävlingsuppehåll sedan femteplatsen i årets Elitlopp, där han travade sitt rekord 1.08,8a/1.609 meter.<br>Från Elitloppsfinalen dyker även försöksvinnaren <strong>Go On Boy</strong> (e. Password) upp. Romain Derieux har gjort en start efter Solvallabesöket, då han slutade tvåa i Kymi Grand Prix bakom <strong>Borups Victory</strong> (e. Googoo Gaagaa).<br>Toppstoet <strong>Ampia Mede Sm</strong> (e. Ganymede) gör comeback efter nästan fem månaders frånvaro och detta sker i ny regi. Efter Prix de Paris lämnade hon Fabrice Souloy och återfinns numera i Thierry Duvaldestins träning.</p>



<p>För svensk del startar Björn Goop en duo: <strong>La Comtesse Madrik</strong> (e. Django Riff) i Prix d’Escurolles (€35.000) och <strong>Icarus Bourbon</strong> (e. Prodigious) i Prix de Romainville (€46.000). Francois Lagadeuc och Yoann Lebourgeois är anlitade av kuskar.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/enghien-2024-07-13/" target="_blank" rel="noreferrer noopener">Här är startlistorna till Enghiens tävlingar idag.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/evartti3-617x333.jpg" alt="" class="wp-image-449838"/><figcaption class="wp-element-caption">Evartti vid segern i Elitkampen tillsammans med Santtu Raitala 2022. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">6Sex hästar som sprungit under 1.19. Varmblodslopp? Nej, finska Mikkeli bjuder på en högklassig upplaga av sprinterloppet Suurmestaruus Ajo med 25.000 euro i förstapris i eftermiddag.</p>



<p>Förra året noterades tidernas bästa kallblodstid i Finland när <strong>Evartti</strong> (e. K.M.Nopa) vann på 1.18,4a/1.609 meter tillsammans med Santtu Raitala. Fem hästar travade under 1.19 och samtliga finns med i årets upplaga.<br>Segermaskinen <strong>Parvelan Retu</strong> (e. Liising), som vunnit 53 av 71 starter, har bara gjort två starter i år och var för två veckor sedan tvåa i Suur-Hollola (€66.000) bakom då 20 meter framför startande <strong>V.G.Voitto</strong> (e. Viesker). Denne finns också med i dagens lopp.<br>Parvelan Retu drog andraspår bakom bilen medan Evartti har spetsläge från spår fyra.</p>



<p><strong>Startlista Suurmestaruus Ajo (€52.500)</strong><br>1.609 meter autostart, förstapris 25.000 euro:<br><em>Häst (far) – Kusk – Rekord</em></p>



<ol class="wp-block-list">
<li><strong>Herra Heinämies</strong> (e. Viesker) – Jukka Torvinen – 1.18,7ak</li>



<li><strong>Parvelan Retu</strong> (e. Liising) – Hannu Torvinen – 1.18,5ak</li>



<li><strong>Stallone</strong> (e. Frans) – Antti Teivainen – 1.18,9ak</li>



<li><strong>Evartti</strong> (e. K.M.Nopsa) – Santtu Raitala – 1.18,4ak</li>



<li><strong>Issakan Valo</strong> (e. Camri) – Iikka Nurmonen – 1.19,8ak</li>



<li><strong>Philip Ess</strong> (e. Briskeby Philip) – Henri Bollström – 1.19,8ak</li>



<li><strong>H.V.Tuuri</strong> (e. Turo) – Olli Koivunen – 1.18,6ak</li>



<li><strong>Caijus</strong> (e. Cameron) – Tommi Kylliäinen – 1.18,6ak</li>



<li><strong>Uljas Suomalainen</strong> (e. Sirpan Sisu) – Tapio Perttunen – 1.20,0ak</li>



<li><strong>V.G.Voitto</strong> (e. Viesker) – Ari Moilanen – 1.20,9ak</li>
</ol>



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



<p class="has-drop-cap">7Traveras internetauktion ikväll bjuder på 14 hästar i den digitala katalogen och den mest meriterade är nästanmiljonären <strong>Victory Lee</strong> (e. Joke Face). Ett kallblod säljs också, ett högättat sådant i femårige <strong>Blomsterkungen</strong> (e. Tekno Odin), som är bror till självaste Stjärnblomster (4,1 miljoner) och fyraåriga drottningen Majblomster (1,8 miljoner).</p>



<p>Tre fölston (e. Muscle Massive, Raja Mirchi och Windsong’s Legacy) är också till salu. Den sistnämnda är dräktig med Tatical Landing.</p>



<p><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här går det att se hästarna som säljs och följa budgivningen under kvällen.</a></p>
