
<p class="has-drop-cap wp-block-paragraph">På lördag avgörs V75 på Bodentravet som är landets nordligaste bana och då handlar det även om Midnattstrav. Att evenemanget dessutom kryddas med en jackpot på 43 miljoner kronor kittlar förstås lite extra. Observera att första V75-start är 20.30.</p>



<p class="wp-block-paragraph">Norrbottens Stora Pris (V75-7) är förstås huvudnumret med en miljon kronor till vinnaren och det är stor chans att Daniel Redéns sexåring <strong>7 Francesco Zet</strong> lägger beslag på prischecken tillsammans med sin ständige följeslagare Örjan Kihlström. Han slutade fyra i Elitloppet och är revanschsugen. Singelstreck!</p>



<p class="wp-block-paragraph">Det andra singelstrecket blir lite av en chansning i kallblodsloppet (V75-4), som känns lite som en eller alla. Vi väljer nämligen att ta ställning för vasse Ingvar Nyberg bakom <strong>2 Tåga Ryker</strong>, som visat toppform på sistone.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/06/15v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna på Bodentravet.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2024-06-15_11_7" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2024-06-15_11_7" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<h2 class="wp-block-heading">Avd 1 – Silverdivisionen, 2140 meter autostart </h2>



<ul class="wp-block-list">
<li>Daniel Wäjersten tog en fyrling i lördags som tränare på V75 och sitter på leken i det här silverloppet då han selar ut en trio. Tipset får <strong>3 H.C.&#8217;s Crazy Horse</strong>, som satt i fjärde inner på Mantorp och avslutade med 1.10 sista varvet efter sen lucka. Bättre läge nu. </li>



<li><strong>4 Heartbeat Thunder</strong> var helt ensam på ovalen i Skellefteå. Formen är helt på topp och är Wäjerstens val.</li>



<li><strong>5 Night Art</strong> är också tidig. Satt i andra ytter senast och när luckan väl kom till slut speedade han till säker seger. Amerikansk vagn nu, dessutom.</li>



<li><strong>9 Working Class Hero</strong> var med i Harper Hanovers lopp senast. Lättare emot nu. Även här blir det amerikansk vagn.</li>
</ul>



<p class="wp-block-paragraph"><strong>Ranking</strong> – A: 3,4,5,9 B: 8,6 C: 2,7,10,1 </p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>6 King of Djazz lär prova hårt inledningsvis. Kan kosta mer än det smakar.</p>



<h2 class="wp-block-heading">Avd 2 – Diamantstoet, 2140 meter voltstart</h2>



<ul class="wp-block-list">
<li>Med åtta vinster på elva starter och ytterligare två gånger bland de tre främsta blir naturligtvis <strong>8 Relevant Stride</strong> stor favorit. På Solvalla var hon duktig som tvåa från ledningen. Men nu står hon med 20 meters tillägg och ska dessutom ut på en långresa. Hur hanterar hon det?</li>



<li><strong>2 M.T.Special Girl </strong>kommer med två raka spetsvinster. Från ett bra utgångsläge är det ingen vild gissning att de siktar på samma visa igen.</li>



<li><strong>3 Notice&#8217;em </strong>återkommer efter lite vila. Bra läge och barfota runt om.</li>



<li><strong>8 Grit Brodda</strong> har bakspår och 20 meters tillägg. Ingen bra kombination, men hon står bra inne i loppet och ska även tävla barfota runt om.</li>
</ul>



<p class="wp-block-paragraph"><strong>Ranking</strong> – A: 8 B: 2,3,14,15 C: 4,10,5,7,9,12,6,1,13,11 </p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>2 M.T.Special Girl är snabb i benen. Trycker sig till front?</p>



<h2 class="wp-block-heading">Avd 3 – Klass 2, 2140 meter autostart </h2>



<ul class="wp-block-list">
<li>Mer Wäjersten här, nu bakom <strong>8 Zigzag Zagazoo</strong> som övertog ledningen senast och gick undan lätt till slut. Spår åtta bakom bilen är förstås uselt, men med klaff på bitarna duger han långt.</li>



<li><strong>9 Kurtz</strong> har vunnit tre av de fyra senaste. Kördes till spets varvet kvar senast på Romme och vann säkert. Ett tidigt streck.</li>



<li><strong>7 Heineken Bishop</strong> kommer med tre raka vinster. Hårdare emot nu och han får upp till bevis. </li>
</ul>



<p class="wp-block-paragraph"><strong>Ranking</strong> – A: 8,9 B: 7,12,1,11,3,4 C: 2,10,5,6</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Hemmahästen 4 Summit By Proxy har ett bra läge bakom bilen.</p>



<h2 class="wp-block-heading">Avd 4 – Kallblodsdivisionen, 2140 meter voltstart</h2>



<ul class="wp-block-list">
<li>En eller alla? Vi väljer det första alternativet och lämnar <strong>2 Tåga Ryker</strong> ensam. Nioåringen har förvisso inte vunnit sedan den 29 oktober, men nu kan det vara dags. Han har fått ge sig mot Brageson och Olav på slutet och senast fick han aldrig slag på G.G.Qurre, som vann från spets. Tåga Ryker höll dock strålande och kan skicklige amatören Ingvar Nyberg servera honom ett bra lopp är han ett roligt singelstreck.</li>



<li><strong>6 Prinsen af Sola</strong> har springspår med hete Per Linderoth vid tömmarna, som i lördags tog en V75-dubbel på hemmaplan. Han kör med självförtroende och lär ladda för spets med femåringen.</li>



<li>Tilläggshästarna står tufft till propositionsmässigt, men <strong>13 Pyrotek</strong> körs av Mats E Djuse som är extremt skicklig på den här rasen. Springspår och springband kan emellertid innebära trafikproblem.</li>
</ul>



<p class="wp-block-paragraph"><strong>Ranking</strong> – A: 2 B: 6,13,4,3,5,1,7 C: 8,9,10,14,11,12,15</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> 6 Prinsen af Sola är kvick ut och ska ha goda chanser att ta hand om initiativet.</p>



<h2 class="wp-block-heading">Avd 5 – Bronsdivisionen, 1640 meter autostart </h2>



<ul class="wp-block-list">
<li><strong>1 Imperator F.I.</strong> vann från utvändigt ledaren på Vermo med krafter kvar. Gick även bra som trea på Bollnäs. Kan knappast försvara innerspåret, men bra segerchans om fritt tidigt.</li>



<li>Värst emot är hemmahoppet <strong>6 Last Dying Breath</strong> som Hanna Olofsson siktat hit med. Genrepet i fredags löste han på bästa sätt efter vila. Lär vara ännu bättre nu.</li>



<li>Träter en duo kan en tredje vinna och i så fall är Hanna Olofssons andra bidrag – <strong>10 Henessi Walk</strong> – högaktuell. Han kommer från seger mot silverhästar i förra starten och visade toppform. Bakspår nu, men Magnus A Djuse förstärker i sulkyn. </li>
</ul>



<p class="wp-block-paragraph"><strong>Ranking</strong> – A: 1,6,10 B: 4,3 C: 8,9,2,7,5,11,12  </p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> 6 Last Dying Breath är vrålsnabb och Hanna Olofsson har siktet inställt på spets.</p>



<h2 class="wp-block-heading">Avd 6 – Klass 1, 2640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>10 Kingen Mearas</strong> var med i V75-finalerna på Solvalla. Satt i tredje ytter och gick bra in i mål efter 1.08/s.700. Upp i klass nu och skor på fötterna gör att han känns sårbar från bakspår och given att gardera.</li>



<li><strong>5 Sultan Sea</strong> gör alltid bra insatser och från ett passande läge bakom bilen är femåringen  segeraktuell.</li>



<li>Finske gästen <strong>6 Xeven Leader</strong> kommer med tre vinster på de fem senaste starterna. Finske toppkusken Santtu Raitala kör som vanligt och han ska streckas tidigt.</li>
</ul>



<p class="wp-block-paragraph"><strong>Ranking</strong> – A: 10,5,6,8 B: 11,12,9,7 C: 4,2,3,1  </p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> Magnus A Djuse brukar kunna gasa ordentligt bakom bilen. Spetsar med 5 Sultan Sea.</p>



<h2 class="wp-block-heading">Avd 7 – Gulddivisionen, 2140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>7 Francesco Zet</strong> pinnade runt ovalen på Solvalla två gånger i samband med Elitloppet.  I försöket blev han trea och i Elitloppsfinalen kutade han 1.08,7/1.609 meter autostart – men fick nöja sig med fjärdepriset bakom vinnande Horsy Dream. Nu har Daniel Redéns stridsvagn fått de två genomkörarna i kroppen och formen ska peka rakt uppåt. Ytterst svårslagen.</li>



<li><strong>9 Always Ek</strong> blev etta i försök och tvåa i final i ”lilla Elitloppet” Sweden Cup och svarade för två imponerande insatser för Alessandro Gocciadoro, vars stall är i toppslag för dagen. Från bakspår får han dock nöja sig med att vara första reserv.</li>



<li>Wäjersten har också stallet i topptrim och toppstoet <strong>3 Great Skills</strong> var trea i comebacken efter en resa i tredjespår sista 1200 meterna. Bra läge nu bakom bilen.</li>



<li><strong>5 Castor the Star</strong> är pilsnabb bakom bilen. Barfota runt om nu, men två raka galopper oroar.</li>
</ul>



<p class="wp-block-paragraph"><strong>Ranking</strong> – A: 7 B: 9,3,5,2,6,8 C: 4,1  </p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>5 Castor the Star är som en katapult. 3 Great Skills kan också öppna snabbt.</p>


<div class="factbox full ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									V75-förslaget 15 juni								</h3>
<div class="content">
<p class="wp-block-paragraph"><strong>Avd 1: </strong>3,4,5,9 (8,6) <br /><strong>Avd 2:</strong> 2,3,8,14,15 (4,10) <br /><strong>Avd 3: </strong>1,3,4,7,8,9,11,12 (2,10) <br /><strong>Avd 4:</strong> 2 Tåga Ryker (6,13) <br /><strong>Avd 5:</strong> 1,6,10 (4,3)<br /><strong>Avd 6: </strong>5,6,7,8,9,10,11,12 (1,4)<br /><strong>Avd 7: </strong>7 Francesco Zet (9,3) </p>
<p class="wp-block-paragraph"><em>3.840 rader / 1.920 kronor</em></p>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
