
<p class="has-drop-cap wp-block-paragraph">1Den 14 augusti 2015 är ett magiskt datum på svensk travmark. Då sprang Daniel Redéns stjärnsto <strong>Delicious U.S.</strong> (e. Cantab Hall) 1.08,6a/1.640 meter från bakspår i Bollnäs tillsammans med Örjan Kihlström. Det var världsrekord för ston på 1.000-metersbana.<br>Det var också början på en världsrekordsommar och -höst för Delicious, som satte världsrekord i sina kommande två starter också. Först över medeldistans på Bergsåker med 1.10,0a i Sundsvall Open Trot och slutligen i Müllers Memorial på Jägersro på 1.12,1a/2.640 meter.</p>



<p class="wp-block-paragraph">Tre världsrekord på tre olika distanser i tre starter i rad alltså!</p>



<p class="wp-block-paragraph">Numera är det en annan Daniel Redén-tränad häst som innehar rekordet. Fantastiska <strong>Allegiant</strong> (e. Tactical Landing) som blev världens snabbaste travare genom tiderna när hon vann Elitloppsfinalen på 1.07,1a/1.609 meter.</p>



<p class="wp-block-paragraph">På världsrekordbanan Bollnäs idag (första start 14.35) hyllas Delicious när hon ger namn åt gulddivisionen Bollnäsloppet, som fått tillägget Delicious världsrekordlopp.<br>Kan det gå undan idag då? Den snabbaste vinnaren i historien kom för två år sedan när <strong>Mister Hercules</strong> (e. Trixton) vann på 1.09,4a/1.640 meter. Konstellationen bakom vinnaren var samma som för både Delicious och Allegiant, Daniel Redén tränade och Örjan Kihlström körde.</p>



<p class="wp-block-paragraph">Duon mönstrar ett starkt kort även i år i forne Kriterievinnaren <strong>Xanthis Harvey</strong> (e. Propulsion), som gjorde en toppinsats i dödens i Årjängs Stora Sprinterlopp som tvåa bakom Gio Cash på 1.09,5ak.<br>– Xanthis Harvey är verkligen på gång och senast gjorde han ett topplopp och utmanade Gio Cash hela vägen in mot mål trots ett lopp utvändigt om denne. Han flyttar fram sig hela tiden formmässigt nu när han kan starta kontinuerligt och läget blev bra och han gör en spännande start., säger Daniel Redén på sin hemsida <a href="http://reddis.se">reddis.se</a>.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/07/mellbyjoker-617x333.jpg" alt="" class="wp-image-743326"/><figcaption class="wp-element-caption">Daniel Wäjersten-tränade Mellby Joker. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Ett hett motbud är Daniel Wäjerstens <strong>Mellby Joker </strong>(e. Muscle Hill), som körs av Mats E Djuse från innerspår.<br>– Mellby Joker gjorde en kanoninsats senast på Solänget trots regniga förutsättningar och gick under 1.11 full väg. Han är väldigt snabb ut, hästen går alltid bra och är gynnad av innerspår och där lär hästen hamna från det här läget, sade Daniel Wäjersten till ATG Live.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/07/25v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Bollnäs tävlingar.</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/2025/06/tomaspetterssonsulky-617x333.jpg" alt="" class="wp-image-732836"/><figcaption class="wp-element-caption">Tomas Pettersson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Omsättningssiffrorna för V85 har hackat den senaste tiden och kan inte leva upp till noteringarna för V75-spelet samma tid förra året. Kanske blir det ändring idag när det är jackpot på V85 – nästan 25 miljoner kronor extra ligger i åttarättspotten i Bollnäs, där det spås landa 25 miljoner i högsta vinstpoolen.</p>



<p class="wp-block-paragraph">Detta i en omgång med bland annat tre 15-hästarsfält, varav två kallblodsslopp, och Sulkysports expertpanel har haft en hel del att sätta tänderna i.<br>Ett av skrällbuden hittas i fartfyllda norska gästen <strong>Langlandsballerina</strong>, som dragit innerspår i volten i stoloppet (V85-3). Hon är streckad på åtta procent och Tomas Pettersson kör för första gången. <br>– Hon har sett svår ut från sidan, men hon har fungerat när man har sett henne fått löpa på i ledningen och kanske fått någon längd och fått trava ut och trava lite fritt. Det är min uppfattning när jag sett henne från sidan, sade Tomas Pettersson.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v85-tips-bs-25-juli/" target="_blank" rel="noreferrer noopener">––> Här är Sulkysports experters bästa vinnare och spikar.</a></p>



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



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/simsalabim/V85_2026-07-25_12_5">Här finns andelar till V85 hos Simsalabim.</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/69ansspel/V85_2026-07-25_12_5">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/butik/spelpoolen/V85_2026-07-25_12_5">Här finns andelar till V85 hos Spelpoolen.</a></p>



<p class="wp-block-paragraph">Bollnäs bjuder även på ungdomsfinalen i Järvsöfaks Cup för kuskar förra 1996 eller senare. 2022 avgjordes kuskmatchen för första gången och segraren var en viss Mats E Djuse. Han har följts av Frida Johansson, Selma Lindberg och Liv Marie Hansen.<br>I sex försök har två kuskar från varje kvalat in till finalen och där möts dessa kuskar: <br>Lukas Berglind, Erik von Essen, Jill Ivarsson, Henrik Kihle, Ida Olsson, Emelinda Persson, Fredrik Plassen, Noa Reldén, Jarl Andre Smedtorp, Ludwig Wikman, Lucas H Wikström och Olle Wäjersten.</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/2026/05/7inexessbleugiocash-617x333.jpg" alt="" class="wp-image-856514"/><figcaption class="wp-element-caption">Gio Cash i ledning med Inexess Bleu på utsidan efter 500 meter i Elitloppsförsöket. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Kretsen runt <strong>Inexess Bleu</strong> (e. Vittel de Brevol) satsade hårt mot Elitloppet och tränade bland annat extra bakom startbilen på Vincennes innan avresan till Sverige. Elitloppet slutade med en tredjeplats i försöket och galopp i finalen.</p>



<p class="wp-block-paragraph">Resan och Solvallaäventyret satte sina spår hos den franske storstjärnan, men idag på Parisbanan Enghien är han tillbaka i grupp II-klassade Prix Jean-Luc Lagardere (€150.000) över 2.875 meter.<br>– Inexess Bleu fick ta en paus efter starten i Sverige eftersom han hade svårt att återhämta sig efter den insatsen. Jag tycker att han känns fin i träningen nu. Samtidigt hade jag hellre sett att han gjorde den här starten på Vincennes, och jag vill avvakta och se hur det går eftersom upplevelsen på Solvalla tog ovanligt hårt på honom, säger tränaren Laurent Claude Abrivard 24H au Trot.</p>



<p class="wp-block-paragraph">Sonen Alexandre Abrivard sitter som vanligt i sulkyn när Inexess Bleu ställs mot tvåa andra av årets Elitloppshästar, <strong>Jabalpur</strong> (e. Booster Winner) och <strong>Keep Going</strong> (e. Follow You), samt forne Prix d’Amérique-vinnaren <strong>Hooker Berry</strong> (e. Booster Winner).</p>



<p class="wp-block-paragraph">Titelförsvararen <strong>Koctel du Dain</strong> (e. Boccador de Simm) finns också bland motståndarna. Denne blev den näst snabbaste vinnaren i loppet historia förra året när han travade 1.12,1/2.875 meter. Bara 2018 års vinnare <strong>Aubrion du Gers</strong> (e. Memphis du Rib) och Jean Michel Bazire har varit snabbare med 1.11,3 från 2018.</p>



<p class="wp-block-paragraph">Franska hästar har dominerat i loppets historia, men vi hittar också svenskfödda vinnare.  Ulf Nordin satte dit egentränade <strong>Jackhammer</strong> (e. Demilo Hanover) 2000 och för tre år sedan segrade Thierry Duvaldeston-tränade <strong>Oracle Tile</strong> (e. Ready Cash) tillsammans med Theo Duvaldestein.</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/2026/06/scoopdyga125416020-617x411.jpg" alt="" class="wp-image-861551"/><figcaption class="wp-element-caption">Ägaren Anders Ström lägger sin arm över segerkusken Alexandre Abrivard efter Leaderboards seger. Foto: Scoopdyga</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Ingen svensk häst eller tränare i huvudloppet, men det saknas ändå inte blågula inslag i Paris idag. Hela fem svenskfödda travare dyker upp i femåringsloppet Prix de l’Hay-les-Roses (€53.000) över 232.150 meter med bilstart.</p>



<p class="wp-block-paragraph">Jörgen Westholm tränar två av dem och det stora namnet är <strong>Leaderboard</strong> (e. Face Time Bourbon). Hästen inledde sitt franska äventyr på allra bästa sätt med två raka segrar på Vincennes i maj-juni, innan han fick nöja sig med sjätteplatsen i Enghiendebuten.<br>Nu görs ett nytt försök på samma bana när Mathieu Mottier hoppar upp i vagnen och Leaderboard tillhör favoriten i kampen om 23.850 euro i förstapris.</p>



<p class="wp-block-paragraph">Från Westholms stall kommer också <strong>Panerai</strong> (e. Orlando Vici), som Jan Ove Olsen skickat söderut för ett Frankrike-äventyr. Hon har varit sexa och sjua i sina två första starter på Enghien.<br>Övriga svenskfödda hästar i loppet är <strong>Force of Nature</strong> (e. Brillantissime), <strong>Lovely Wilma</strong> (e. Flocki d’Aurcy) och <strong>Mister Lion</strong> (e. Mister J.P.).</p>



<p class="wp-block-paragraph">Jägersroamatören Elke Frinta gör en Frankrikesatsning och plockar ut <strong>Perfect</strong> (e. Southwind Frank) i stoloppet Prix du Palais Royal (€43.000) med Matthieu Abrivard i vagnen. Perfect vann just i Enghien för nästan prick ett år sedan, den 26 juli 2025, och har en spännande uppgift i dagens sista lopp, där även svenskfödda <strong>Edima</strong> (e. Love You) startar.</p>



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



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



<p class="has-drop-cap wp-block-paragraph">5Efter natt-trav på dubbla svenska banor igår är det dags för nästa nattiné ikväll i Kalmar (första start 19.20). Där är Sommarduellen med försök och final samma kväll huvudattraktionen och hela 75.000 kronor väntar vinnaren i finalen.<br>Försöken körs över sprinterdistans med startbil i två klasser, medan de sex främsta i varje möts från två volter över medeldistans i finalen.</p>



<p class="wp-block-paragraph">Den sportsliga höjdpunkten är annars försöket i treåringsserien med hästar som  Per Nordströms <strong>Nobby Stiles</strong> (e. Greenshoe) och Mathias Söderlinds <strong>Marchus K. </strong>(e. Dominion Beach), som vunnit på 1.14-tider över full distans, medan <strong>Isak S.H.Silvio</strong> (e. Fourth Domension) från Fredrik Perssons stall har travat 1.14,4am som trea. 20 meter före startar Johan Untersteiner-tränade <strong>Money Today</strong> (e. Googoo Gaagaa), som vann i livets enda start på 1.15,7m.</p>



<p class="wp-block-paragraph">Dagen inleds med årets andra av tre tävlingsdagar på 800-metersbanan i Arvika (första start 13.00). Nya Travrikeserien rullar vidare med ett försök för vardera ras.<br>Försök på fyra banor tar fram hästarna till finalerna i Årjäng den 18 september med 50.000 kronor till vinnaren i varje. Försök har redan körts på Momarken och Åmål och nu är det alltså Arvikas tur innan sista försöken avgörs på Färjestad. Start i minst ett försök krävs för att vara startberättigad i finalen.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/07/260725.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar.</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/2023/06/stoletheshowdexterdunn-617x333.jpg" alt="" class="wp-image-452132"/><figcaption class="wp-element-caption">Stoletheshow tillsammans med Dexter Dunn i Elitloppet 2023. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6De bästa norska treåringarna på varmblodssidan gör upp i Biris Treåringselit med 300.000 kronor i förstapris i två klasser med kullens klarast lysande stjärna hittills i startfältet. Det handlar om stoet <strong>Express Go</strong> (e. Readly Express), som efter sju starter fortfarande inte vet hur det känns att förlora.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/obesegrad-slipper-kvala/" target="_blank" rel="noreferrer noopener">Läs mer om Biris Treåringselit här.</a></p>



<p class="wp-block-paragraph">Samtidigt ska Norges bästa häst på varmblodssidan koras när Norskt Mästerskap avgörs för hingstar/valacker respektive ston.<br>Vinnaren de fyra senaste åren finns med för att tävla om ännu ett norskt guld. Svenskägde <strong>Stoletheshow</strong> (e. Dream Vacation), som tränas av Frode Hamre, vann tre år i rad 2022-2024. Ifjol stod han över loppet som vanns av dubble Elitloppsdeltagaren <strong>Charron</strong> (e. Code Bon). Båda hästarna tävlade – i olika lopp – på Jarlsberg under storhelgen för tre veckor sedan, men utan framgång. </p>



<p class="wp-block-paragraph">I stoavdelningen plockar Axevallatränaren Victoria Berntsson ut <strong>Annabelle</strong> (e. Explosive Matter), som dock drog nitlotten med spår tolv. Kjetil Helgestad-tränade <strong>Monalisa B.R.</strong> (e. Readly Express) blir favorit.</p>



<p class="wp-block-paragraph"><a href="https://www.travsport.no/travbaner/biri-travbane/startlist/2026-07-25" target="_blank" rel="noreferrer noopener">Här är startlistorna till Biris tävlingar ikväll.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7Fem av nio hästar i fyra- och femåringsloppet Midnight Race (€12.600) med 6.000 euro i förstapris i Torneå i eftermiddag är svensktränade. Det stora namnet är Ann-Catrin Frisks och Ove A Lindqvists jänkare <strong>French Kronos</strong>, som kan mycket när han fungerar men agerar ojämnt. En seger har det blivit i år, medan han avslutade fjol,året med vinst på juldagen i Umeå.</p>



<p class="wp-block-paragraph">Fyra Bodentränade hästar finns bland motståndarna i Petri Salmelas duo <strong>Like Magic Sisu</strong> och <strong>Robinhood C.A,</strong> Hanna Olofssons <strong>Ja Ba Da Ba Doooo</strong> och Sandra Erikssons <strong>Nightwish River</strong>.</p>



<p class="wp-block-paragraph"><strong>Startlista Midnight Race (€12.600)</strong><br>2.100 meter autostart.<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Ja Ba Da Ba Doooo</strong> (e. Donato Hanover) – Hanna Olofsson</li>



<li><strong>Overhead Panel</strong> (e. Uncle Lasse) – Tuukka Varis (Mari Leinonen)</li>



<li><strong>Nightwish </strong>River (e. Propulsion) – Sandra Eriksson</li>



<li><strong>French Kronos</strong> (e. Face Time Bourbon) – Ove A Lindqvist (Ann-Catrin Frisk)</li>



<li><strong>Millstout</strong> (e. Googoo Gaagaa) – Matti Nisonen</li>



<li><strong>Supreme Tantarella</strong> (e. Maharajah) – Tino Keväänranta (Tino Salmela)</li>



<li><strong>Like Magic Sisu</strong> (e. Googoo Gaagaa) – Santtu Raitala (Petri Salmela)</li>



<li><strong>Where’s The Party</strong> (e. Bar Hopping) – Tommi Kylliäinen (Niko Huuskola)</li>



<li><strong>Robinhood C.A.</strong> (e. Walner) – Mika Forss (Petri Salmela)</li>
</ol>



<p class="wp-block-paragraph">Totalt startar 18 svensktränare hästar i Torneo idag och här är de övriga:</p>



<ul class="wp-block-list">
<li>Sandra Eriksson: Asa Always On Time, Swagger.</li>



<li>Janita Luttunen: Backwood Gisella.</li>



<li>Hanna Olofsson: Hjalmar Express, Enjoy Beaufort, Lars Dying Breath.</li>



<li>Petri Salmela: Federer Broline, Speed Matters, Backwoods Ferguson, Mervellieux Sisu, Pielinen Boko, Henry Flyer Sisu.</li>



<li>Johnny Sandman: No Regrets Renka.</li>
</ul>



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

Fokustema
Sju nyheter vid sju
Läs senare
I Delicious hovspår…
Fartfest på världsrekordbanan Bollnäs? 25 miljoner extra i potten i V85-jackpot. Inexess Bleu har slickat såren efter Elitloppet. Svenskmöten i Paris. Från natt-trav till natt-trav. Svenskägd kan bli norsk mästare – igen. Blågul satsning i Finland.
Detta och mer bland lördagens ”Sju nyheter vid sju”.
Detta och mer bland lördagens ”Sju nyheter vid sju”.
