
<p class="has-drop-cap wp-block-paragraph">Traditionsenligt är det Gävletravet som arrangerar V75-omgången veckan innan Elitloppshelgen gör entré.</p>



<p class="wp-block-paragraph">Klassen på tävlingarna är förhållandevis god, men vi är rädda för att utdelningen ånyo kan bli sparsam då det är många lopp som känns skiktade och där favoriterna står inför lämpliga uppgifter.</p>



<p class="wp-block-paragraph"><strong>PolePosition</strong> (V75-1) är en sådan springare. Vi tycker att han alltjämt tävlar i för låg klass som bronsdivisionare och när han därtill fick ett utgångsläge som talar för att han ska vinna starten så blir han svår att fånga in för de övriga.</p>



<p class="wp-block-paragraph"><strong>Erik the Phantom</strong> (V75-3) riskerar en desto tuffare inledning i sitt lopp, men det tror vi är av akademisk betydelse.<br>Sett till vilka toppar han matchade under fjolåret talar mycket för att han kommer vandra genom klasserna i sommar och vi spikar honom i Klass I-försöket trots att han travar igång från spår åtta.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/05/18v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna i Gävle.</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-05-18_16_5" 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-05-18_16_5" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<h2 class="wp-block-heading">Avd 1 – Bronsdivisionen, 2.640 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>PolePosition</strong> sköt till riktigt fint i årsdebuten när luckan uppenbarade sig och avgjorde det loppet på ett mycket fint vis. Gången efter startade han i Lyon Grand Prix och forcerade måhända lite väl hastigt fram efter ett knappt varv i jakt på ledningen och slog på en galopp. Vi tyckte på intet vis att hästen såg dålig ut och förväntar oss att han är tillbaka med besked i detta lopp som ser väldigt passande ut på pappret.</li>



<li><strong>Cabasse</strong> fick en tuff väg fram till dödens i debuten för Björn Goop och höll farten starkt som fyra. 2022 års Sprintermästarfyra tycks åter riktigt på gång efter att inte fått till det i varken Frankrike eller Italien och är med och hugger om PolePosition inte har sin bästa dag.</li>



<li><strong>Matiere</strong> var riktigt rejäl vid dödenssegern i årsdebuten och det såg ut som att han hade löst även den efterföljande starten om det inte vore för en galopp 75 meter före mål. Nu blir det en dryg månad mellan starterna, men det viktigaste är trots allt att hästen är fräsch och fin för då är han riktigt bra för sammanhanget.</li>



<li><strong>Grand Ready Cash</strong> höll strongt som dödenstvåa bakom Underbarosåfin senast på Umåker. Andraspår i volten kan vara lurigt för den tyskfödda sexåringen, men travar han iväg är han med och slåss om tätplatserna.</li>



<li><strong>Västerbo Tramp</strong> är i knallform och kan få rena drömloppet här i rygg på PolePosition. Vi blir inte alls förvånade om han håller farten så starkt att han slutar tvåa och kombspelet 1-8 behöver inte alls vara fel.</li>
</ul>



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



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



<p class="wp-block-paragraph"><strong>Spetsstriden: PolePosition</strong> har frontat från spår ett i voltstart tidigare och ska ha god chans att hålla ut <strong>Matiere</strong> från början.</p>



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



<ul class="wp-block-list">
<li><strong>Rams Bror </strong>blir vårt tipsval i denna jämna final av Kallblodsdivisionen. Han anförde från start till mål senast trots att han inledde från ett snävt startspår och är verkligen rask ur groparna. Från springspår har han jättebra chans att ta ledningen i lag med Erik Adielsson och då är detta hästen att slå för de övriga.</li>



<li><strong>Arding</strong> låter vi dock göra honom sällskap i A-gruppen. Det här är troligtvis fältets mest kapabla häst, men femåringen är inte helt enkel och innerspår på 20 meters tillägg är ett lömskt utgångsläge om det är så att man blir över från början. Att runda hela fältet fårn djup köposition om man hamnar långt bak på Gävles raska oval är inte gjort i en handvändning, men med minsta flyt på vägen blir Arding tuff att hålla emot.</li>



<li><strong>Järvsö Jop</strong> har bärgat två raka dödenssegrar på rejält vis och tycks bättre än någonsin just nu. Hästen kan vara lite vass mellan varven och fjärdespår i volten är inget optimalt utgångsläge, men trampar han iväg i rätt gångart så ska han stå sig bra även här.</li>



<li><strong>Svarte Petter </strong>är också en herre som inte är helt enkel att räkna på, men att grundkapaciteten räcker till för att segerstrida tvivlar vi inte en sekund på. Han stod för en stark upphämtning efter tidig galopp senast på Dannero och är med i matchen här om han håller sig på benen.</li>



<li><strong>Tekno Filur </strong>slog på en galopp efter 150 meter senast på Bergsåker och det finns risk att det blir för många ben även här när han inleder från ett snävt startspår. Travar han däremot så är han tillräckligt bra för att matcha en sådan häst som Rams Bror när det kommer till grundkapacitet.</li>
</ul>



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



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



<p class="wp-block-paragraph"><strong>Spetsstriden: Rams Bror</strong> är rask ur groparna och vi förväntar oss att vinner starten.</p>



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



<ul class="wp-block-list">
<li><strong>Erik the Phantom </strong>var spelad till andrahandsfavorit bakom Joviality i sitt derbyförsök i augusti, men fick nöja sig med en fjärdeplats den dagen. Nu gjorde han nyligen comeback efter åtta månaders tävlingsuppehåll och stod för en strålande uppgift då han jagade ikapp till vinst från sjätte utvändigt efter ett mycket rejält slutvarv. Vi tror att Erik the Phantom har god chans att vinna det här loppet även om han får ta dödens på värsta konkurrenten.</li>



<li><strong>Sparky&#8217;s Dream </strong>tog dödens halvvägs in i loppet senast i Gävle och höll farten väl bakom Cameron. Anders Erikssons Maharajah-son vann över lång distans i ett Klass II-försök i november, men vi tycker inte att han mötte samma klassiga hästar i det loppet som han stöter på här.</li>



<li><strong>Rajon</strong> har gjort två starter efter uppehåll och varit riktigt bra i båda de loppen. Näst senast i årsdebuten kämpade han på storstilat från dödens och gången efter spurtade han rappt från tredje invändigt i ett Klass I-försök. Med klaff på bitarna här så är han med och slåss om tätplatserna.</li>



<li><strong>Mellby Kaliber </strong>är anmäld barfota runt om för första gången vilket kittlar, men vi är ändå lite tveksamma till om han är rask nog för att besegra Erik the Phantom på en snabb sommarbana över medeldistans.</li>



<li><strong>Jascal </strong>visade riktigt hög nivå i sina prestationer i höstas då han tände till rejäl på barfotabalans. Nu blev det inget riktigt lopp för honom i comebacken då han galopperade i slutkurvan och hästen är per automatik mycket svårbedömd i det här loppet.</li>
</ul>



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



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



<p class="wp-block-paragraph"><strong>Spetsstriden: Sparky&#8217;s Dream</strong> har bra chans att jobba sig förbi <strong>Mellby Kaliber</strong>, men vi undrar om Anders Eriksson verkligen vill ta emot <strong>Erik the Phantom</strong> i skede två.</p>



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



<ul class="wp-block-list">
<li><strong>Mahala</strong> slutade sexa i såväl finalen av Derbystoet som Breeders Crown under fjolåret. Hon stod för en stark återkomst på svensk mark efter en vinter i Paris genom att spurta in som tvåa bakom tuffa Riet Hazelaar och såg inte trött ut då galoppen kom 250 meter före mål i efterföljande start på Åby bakom Decision Maker. Att runda konkurrenter från 20 meters tillägg på snabba sommarbanor är inte gjort en handvändning, men samtidigt är inte konkurrensen den allra tuffaste.</li>



<li><strong>Waypoint Sequence</strong> har matchats i tuffa sällskap i början av detta år och inte sällan fått tuffa löpningsförlopp därtill. Den här uppgiften kittlar då hon ska kunna öppna snabbt från ett sådant här utgångsläge och från ledningen är hon hästen att besegra för de övriga.</li>



<li><strong>Lilly Avant </strong>pressade sig till ledningen senast och gick undan med säker marginal efter att det enda kvarvarande hotet galopperat 150 meter före mål. Det kan bli tufft för henne att vinna starten, men lyckas Björn Goop ta sig ut i fritt slagläge med stoet i sin första bekantskap bakom henne så är hon med och strider om segern.</li>



<li><strong>Karma Mearas </strong>tillhörde skiktet under de bästa i kullen ifjol och var finalist i långa E3-finalen. Trampar Face Time Bourbon-dottern iväg i rätt gångart från snävt startspår kan vi se henne utmana om segern direkt i för sin nya tränare Markus B Svedberg för kapacitetsmässigt är hon knappast sämre än någon annan häst i loppet.</li>



<li><strong>Make It A Star </strong>spurtade ner Happy Go Pepper senast i Gävle och var riktigt rejäl. Att lösa denna uppgift bakifrån blir tuffare, men vi räknar absolut inte bort henne.</li>
</ul>



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



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



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Vi tror att<strong> Power Vacation</strong> kommer förbi<strong> Lilly Avant </strong>och därefter släpper till <strong>Waypoint Sequence</strong>.</p>



<h2 class="wp-block-heading">Avd 5 – Klass II, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Oracle Vixi </strong>galopperade underligt i tät 850 meter före mål i Klass II-försöket på Bergsåker den 17 februari och står därför kvar i en låg klass. Han har haft usla startspår i tuffa sällskap tre gånger i följd efter det och gjort bra insatser i skymundan utan att få så mycket prispengar med sig hem. Den här uppgiften är mycket intressant med tredjespår bakom startbilsvingen och det är anmält såväl barfota runt om som med jänkarvagn. Vi tror att hästen vinner starten och håller hela vägen över korta häcken i ett riktigt svagt Klass II-försök.</li>



<li><strong>Bjorn</strong> lade iväg raskt bakom bilen senast, men lyckades inte ta sig till ledningen. Han fick vandra utvändigt ledaren och höll starkt till andraplatsen även om han blev utkontrad av Superior Bro den sista biten. Hästen har bara fått löpa ut i ledningen en gång och då höll det hela vägen så skulle han ta sig förbi Oracle Vixi på nytt är det knapp fördel för Bjorn, men vi tror som sagt att Oracle Vixi är den raskare av de två initialt.</li>



<li><strong>Queen of the Night </strong>fick lägga mycket kraft för att ta över ledningen senast och fick aldrig riktigt vara i fred efter det. Med tanke på det tycker vi att stoet höll starkt som fyra och hon lär inte vara sämre nu med ett par lite tuffare, utmanande lopp i kroppen.</li>



<li><strong>Semifreddo S.F. </strong>var fyra i ett Breeders Crown-kval på Färjestad och växlade ner sina konkurrenter via vinnarhålet på Romme den 7 maj. Hästen är bra för klassen, men detsamma går inte säga om utgångsläget. </li>



<li><strong>Tarpon Springs </strong>har bara en seger på 32 starter, men totalt sett är det här inget märkvärdigt Klass II-försök. På en positiv insats i senaste starten, lämpligt utgångsläge och chans att få en position långt fram i fältet blir han ett någorlunda tidigt bud.</li>
</ul>



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



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



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>När det växlas upp i kvadrat kring <strong>Oracle Vixi</strong> så lär Örjan Kihlström göra allt som står i hans makt för att hålla ut <strong>Bjorn</strong>.</p>



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



<ul class="wp-block-list">
<li><strong>Hail Mary</strong> fick tredjespår fram till dödspositionen i Finlandia Ajo och då var han helt enkelt oförmögen att plocka ner Stoletheshow samt svara Catullo Jets vassa slutrökare. Med två lopp i kroppen förväntar vi oss att han tar steg framåt på formkurvan och det är mycket gynnsamt att ha spår ett bakom över 1.609 meter kontra 1.640 meter. Vinner han starten blir vi förvånade om han inte vinner loppet.</li>



<li><strong>Staro Mack Crowe</strong> flög fram i spurten i Finlandia Ajo, men satt för långt bak för att få med sig mer än ett femtepris från det loppet. Katja Melkkos häst har tagit steg för varje start i år och när han nu är anmäld barfota runt om för första gången så är vi mycket förväntansfulla kring hur han ska prestera.</li>



<li><strong>Clarissa</strong> fick en blytung resa i comebacken med tredjespår första varvet innan hon nådde fram utvändigt ledaren 650 meter före mål. Att jaga ikapp <strong>Mister Hercules</strong> var en omöjlig uppgift i det skedet, men stoet kämpade på strålande till andraplatsen.</li>



<li><strong>Click Bait</strong> släppte ledningen till Don Fanucci Zet senast efter att flugit till ledningen. Han hakade på starkt till tredjeplatsen och brukar komma i toppform under senvåren. Ifjol var han tvåa i motsvarande lopp och året innan det gick han segrande ur striden så vi förväntar oss stora saker av Click Bait på nytt.</li>



<li><strong>Mister Hercules </strong>vann det här loppet ifjol från just sjundespår bakom bilen och blytung löpning. Vi tycker att konkurrensen är tuffare detta år och tror han får svårt att upprepa den bedriften.</li>



<li><strong>Stoletheshow</strong> kommer från seger i Finlandia Ajo efter att hållit ut Hail Mary och fått överta ledningen. Vi tror att det blir svårare för honom att nå tätpositionen denna gång och från andraspår vinner han knappast det här loppet.</li>
</ul>



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



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



<p class="wp-block-paragraph"><strong>Spetsstriden: Hail Mary</strong> gynnas av att det är 1.609 meter istället för 1.640 meter, men det blir ändå kämpigt att hålla ut <strong>Stoletheshow</strong> och <strong>Click Bait</strong>. Den sistnämnde är &#8221;vidrigt&#8221; rask när han skickas iväg och tål att köras på med full kraft genom kurvan.</p>



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



<ul class="wp-block-list">
<li><strong>Caio Titus Bond</strong> vann Grupp I-lopp i Italien som treåring och har historiskt sett tävlat i betydligt tuffare sammanhang än vad han stöter på här. Vid Silverdivisionsstarten senast på Vermo hade han precis som nu innerspår bakom bilen, blev fast med rubbet sparat i tredje invändigt och behövde nog inte ens duschas efteråt. Lyckas Alessandro Gocciadoro ta sig ut i andraspår här lär det bli ett offensivt upplägg och vi kan se Caio Titus Bond lösa uppgiften från dödens.</li>



<li><strong>Xanthis Hilton</strong> var för peppad i comebacken på Åby och galopperade direkt från start. Gången innan höll han starkt från dödens i samma klass och det blir spännande att se om han kan nå en andra &#8221;formvåg&#8221; nu under våren efter att varit igång länge och levererat på en hög nivå. Stefan Melander har anmält hästen barfota runt om och skulle Xanthis Hilton trycka sig förbi och överta ledningen är mycket vunnet.</li>



<li><strong>Mizai</strong> har bara vunnit en av 15 starter inom V75 på svensk mark, men vi vill inte avsåga honom för det. Hästen fick fel typ av lopp i senaste starten med för mycket grovjobb och vann dessförinnan från tät trots en stenhård öppning. Vi blir inte helt överraskade om man chansar och kör i ledningen nu trots att konkurrensen är tuff.</li>



<li><strong>Heartbeat Thunder</strong> galopperade i en trång situation efter 300 meter i lördags som tillsynes störd. Där laddar man om snabbt och sett till hur fin femåringen var motsvarande period ifjol så räknar vi med honom som ett tidigt bud.</li>



<li><strong>Joe Dalton</strong> hakade på starkt som fyra i Kjell P Dahlströms Minne näst senast och kan ta många i spurten om han kommer fram i rätt ryggar fram tills spurtrakan.</li>
</ul>



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



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



<p class="wp-block-paragraph"><strong>Spetsstriden: Mizai</strong> har god chans att ta hand om ledningen och vi blir inte helt förvånade om Mats E Djuse väljer att testa och köra i tät på Gävletravets raska oval då den positionen är guld värd. Annars blir<strong> Xanthis Hilton </strong>som övertar.</p>



<p class="wp-block-paragraph">	
				<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 18 MAJ								</h3>
														<div class="content">
								
<p class="wp-block-paragraph"><strong>Avd 1: </strong>1 PolePosition (11,6)<br><strong>Avd 2:</strong> Samtliga hästar (6,10)<br><strong>Avd 3: </strong>8 Erik the Phantom (5,10)<br><strong>Avd 4: </strong>1,2,7,12 (10,13)<br><strong>Avd 5:</strong> 3,6,8,10 (4,1)<br><strong>Avd 6: </strong>1,2,4,5 (7,3)<br><strong>Avd 7: </strong>1,2,3,6 (11,8)</p>



<p class="wp-block-paragraph"><em>3.840 rader / 1.920 kronor</em></p>
							</div>
						</div>
					</div>
				</div>
							</div>
		</div>
	
	</p>
